diff --git a/deps/acelite/ACE-INSTALL.html b/deps/acelite/ACE-INSTALL.html deleted file mode 100644 index c05056712..000000000 --- a/deps/acelite/ACE-INSTALL.html +++ /dev/null @@ -1,3231 +0,0 @@ - - - Building and Installing ACE and Its Auxiliary Libraries and Services - - - - - - - - -
-

Building and Installing ACE and Its Auxiliary Libraries and Services

- -

Synopsis

- -The file explains how to build and install ACE, its Network Services, -test suite and examples on the various OS platforms and compilers that -it has been ported to. Please consult the NEWS and -ChangeLogs files to see whether any recent changes -to the release will affect your code. In addition, you should check -out our development -process. As you start working with ACE, we suggest you get copies -of the C++NPv1, C++NPv2, and -APG books to help -guide you after you've built and installed ACE. You should also -consult the ACE -Frequently Made Mistakes page. If you encounter any problems or -would like to request an enhancement, then use github - to submit an issue in accordance with our bug -report process.

- -

Document Index

- - - - -

-

Platforms, C++ Compilers, and Support

- -

ACE has been ported to a large number of platforms using many different -compilers over the years. -The DOC group, -Riverace, -OCI, -Remedy IT, and members of the ACE -user community have all contributed ports to make ACE the successful -and far-reaching toolkit it is today. Any UNIX/POSIX/Windows -variation is probably an easy target platform for ACE. If you have -porting questions or have a problem -compiling the ACE source distribution, please contact one of the -commercial support companies, or send a copy of the -PROBLEM-REPORT-FORM, located in the -ACE_wrappers directory to ace-users -mailing list or create a github issue. -The DOC groups at Washington University, UC Irvine, and Vanderbilt -University provide only "best effort" support for non-sponsors for the -latest release, as described in -docs/ACE-bug-process.html. -Thus, if you need more "predictable" help, or help with earlier versions of -ACE, it's recommend that you check out the -list of -commercial support companies for additional assistance. -

-

The responsibility for maintaining ACE across the wide range of -supported platforms is divided among a few different groups: -

-The -build scoreboard -records the current status of build and regression testing during -development by all of the above groups. It is available to all users wishing -to provide build results. Members of the ACE community that maintain ACE on -platforms not maintained by the DOC group, Riverace, OCI, or Remedy IT are -encouraged to provide build and regression test results for the scoreboard -to ensure that all in-use platforms are represented. -See the autobuild README for more information about -how to set up a build; contact one of the above groups to inquire about how -to get your build results recorded on the scoreboard.

-

Because older -platforms that are not maintained tend to fall into a broken state and -clutter the ACE sources with code that is no longer used, the development -team reserves the right to remove ACE configuration files and source code -specific to inactive platform configurations that are not -listed on the scoreboard.

-

The table below summarizes each group's role and where you can get more -detailed information. For information on TAO's platform coverage and -support, please also see TAO's install -document.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Groups Involved in ACE Development and Support
GroupPlatformsFor more information
DOC Group - DOC sites at ISIS, - UCI and - Washington University -
RiveraceOffers ACE - training, - support and - consulting services - for many platforms including AIX, HP-UX, Linux, Solaris, and Windows. - Riverace's ACE - Support page.
OCIMaintains ACE on certain platforms required for their TAO - software and service offerings. - - OCI's web site, - TAO page, - and the TAO install document
Remedy ITMaintains ACE on many platforms required for their ACE and - TAO service offerings. We support AIX, - Embarcadero C++ Builder, - Windows CE, MinGW, Microsoft Visual C++, GCC, - Cygwin, VxWorks 6.x (kernel and rtp), OpenVMS on IA64, - BlueCAT Linux, RedHat Linux, Fedora, MacOSX, Solaris, - Tru64, SuSE Linux on Alpha/IA32/EM64T/IA64, RTEMS, QNX, LynxOS, - HPUX on IA64, and Android. - The Intel C++ compiler is supported on - Windows 32/64bit, Linux IA32/EM64T/IA64, MacOSX. - Remedy IT web site and - the TAO install document -
PrismTechMaintains ACE on certain platforms required for their TAO - software and service offerings, including LynxOS. - PrismTech's web site
ACE user communityResponsible for continued maintenance and testing of platforms - to which ACE has been ported, but aren't supported by the - above groups. These include - Digital UNIX (Compaq Tru64) 4.0 and 5.0; - IRIX 6.x; UnixWare 7.1.0; - Linux on PPC; OpenMVS; - Tandem; SCO; FreeBSD; NetBSD; OpenBSD; - Macintosh OS X; OS/9; PharLap ETS 13; - QNX RTP and Neutrino 2.0; Interix (Windows Services for Unix) -
Not maintainedThe following platforms have been ported to in the past but are - no longer maintained and may be removed from ACE at any time. - If you want to have support for these environments contact one - of the commercial support organisations. The platforms include: - Chorus; DG/UX; HP-UX 9, 10 and 11.00; pSOS; - SunOS 4.x and Solaris with SunC++ 4.x; VxWorks 5.4 and earlier; - Microsoft Visual C++ 5, 6, and 7.0; Borland C++ Builder 4, 5, 6, and 2006. - For up-to-date listings on platform that are deprecated and pending - removal from ACE, please see the NEWS file. -

- -

Although the DOC group has provided outstanding support for ACE -over the years, ACE's success has greatly increased the amount of -effort required to keep up with its maintenance, answer users' -questions, and give design guidance. Riverace offers world-class -commercial services to support ACE users. OCI, PrismTech, and Remedy -offer similar services for ACE and TAO, allowing the DOC group's primary focus -to shift back to their main goal: research. The DOC group is -fundamentally focused on (and funded -by) advanced R&D projects. The group continues to be -intimately involved in ACE+TAO development and maintenance, but with -revised priorities for maintenance. The bug -fixing policies followed by the DOC group are designed to strike a -balance between their many research -projects and their commitment to the ACE+TAO user -community. Naturally, we will be happy to accept well-tested -patches from the ACE+TAO user community for any platforms that aren't -supported by the DOC group, Riverace, OCI or Remedy IT.

- -

-

Installation prerequisites

- -

ACE (as well as TAO and CIAO) use MPC -(MakeProjectCreator) to generate files used by all supported build -tools (such as GNUmakefiles for UNIX based platforms, sln and vcproj -files for Visual Studio and Embarcadero makefiles) on various platforms. To -help new users to bootstrap quickly the release bundles of ACE (as -well as TAO) include all needed files to use the build -instructions in this document. - -

-

-If it is necessary to generate -files for build tools for other compilers, one must -run MPC to generate the -appropriate files. Please see USAGE, README, and README for ACE files for -details. The options that have been used to generate the above build -files can be found in -global.features file. -

- -
-

Building and Installing ACE

- -The following sections explain how to build ACE on: - - -

General Rules

- - -
-

Building and Installing ACE on UNIX

- -As of ACE 6.0.6, you can building ACE on -UNIX with: -
    -
  1. Traditional ACE/GNU Make Configuration
    2. -
-The build process for Windows is different from -the UNIX methods. - -

Using the Traditional ACE/GNU Configuration

-

-Here's what you need to do to build ACE using GNU Make and ACE's traditional -per-platform configuration method:

- -
    -
  1. Install GNU make - 3.79.1 or greater on your system (available via http - anonymous ftp from ftp.gnu.org in the - pub/gnu/make/ directory). - You must use GNU make when using ACE's traditional - per-platform configuration method or ACE won't compile. -
    2. -
  2. Add an environment variable called ACE_ROOT that contains the - name of the root of the directory where you keep the ACE wrapper - source tree. The ACE recursive Makefile scheme needs this information. - There are several ways to set the ACE_ROOT variable. For example: -
    - TSCH/CSH: - setenv ACE_ROOT /home/cs/faculty/schmidt/ACE_wrappers -
    -
    - BASH or Bourne Shell: - export ACE_ROOT=/home/cs/faculty/schmidt/ACE_wrappers - -
    -

    - If you're building a number of versions of ACE, however, (e.g., for - different OS platforms or for different releases of ACE) you might use - the following approach (assuming TCSH/CSH): -

    - setenv ACE_ROOT $cwd -
    -
    3. -
  3. Create a configuration file, $ACE_ROOT/ace/config.h, - that includes the appropriate platform/compiler-specific - header configurations from the ACE source directory. For example: -
    -#include "ace/config-linux.h" -
    - The platform/compiler-specific configuration file - contains the #defines that are used throughout ACE to indicate - which features your system supports. See the - $ACE_ROOT/ace/README file for a description of these - macro settings. If you desire to add some site-specific or build-specific - changes, you can add them to your config.h file; place them - before the inclusion of the platform-specific - header file. -

    - There are config files for most versions of UNIX. If there - isn't a version of this file that matches your - platform/compiler, you'll need to make one. Please send email - to the ace-users list - if you get it working so it can be added to the master ACE - release.

    -
    4. - -
  4. Create a build configuration file, - $ACE_ROOT/include/makeinclude/platform_macros.GNU, - that contains the appropriate platform/compiler-specific - Makefile configurations, e.g., -
    -include $(ACE_ROOT)/include/makeinclude/platform_linux.GNU -
    - This file contains the compiler and Makefile directives that are - platform/compiler-specific. If you'd like to add make options, you - can add them before including the platform-specific configuration.

    - NOTE! There really is not a # character before 'include' in the - platform_macros.GNU file. # is a comment character. -

    5. -
  5. If you wish to install ACE (using "make install"), set the - installation prefix in platform_macros.GNU. -
    -INSTALL_PREFIX = /usr/local -
    - Headers will be installed to $INSTALL_PREFIX/include, executables to - $INSTALL_PREFIX/bin, documentation and build system files to - $INSTALL_PREFIX/share and libraries to $INSTALL_PREFIX/lib. The library - directory can be customized by setting INSTALL_LIB (for example, - INSTALL_LIB=lib64). With INSTALL_PREFIX set, RPATH will be enabled for - all executables and shared libraries. To disable RPATH (for example, - if $INSTALL_PREFIX/$INSTALL_LIB is already a system-known location for - shared libraries such as those listed in /etc/ld.so.conf), set the make - macro install_rpath to 0 by adding install_rpath=0 to platform_macros.GNU. -
    6. -
  6. Note that because ACE builds shared libraries, you'll need to set - LD_LIBRARY_PATH (or equivalent for your platform) to the directory - where binary version of the ACE library is built into. For example, - you probably want to do something like the following: -
    - % setenv LD_LIBRARY_PATH $ACE_ROOT/lib:$LD_LIBRARY_PATH
    - - or -
    - % export LD_LIBRARY_PATH=$ACE_ROOT/lib:$LD_LIBRARY_PATH
    - -
    7. -
  7. When all this is done, hopefully all you'll need to do is type: -
    - % make
    - at the ACE_ROOT directory. This will build the ACE - library, tests, the examples, and the sample applications. - Building the entire ACE release can take a long time and consume - lots of disk space, however. Therefore, you might consider - cd'ing into the $ACE_ROOT/ace directory and - running make there to build just the ACE library. - As a sanity check, you might also want to build and run the - automated "one-button" tests in - $ACE_ROOT/tests. Finally, if you're also - planning on building TAO, you - should build the gperf - perfect hash function generator application in - $ACE_ROOT/apps/gperf. -
    8. -
  8. If you've set the INSTALL_PREFIX before building, now run -
    % make install
    -
    9. -
  9. If you need to regenerate the ace/Svc_Conf_y.cpp file, - you'll need to - get GNU Bison. - However, you should rarely, if ever, need to do this. -
    10. -
- -
- -

Building and Installing ACE on Windows

- -

This section contains instructions for building ACE on Microsoft -Windows with a variety of compilers and development environments.

- -

First, if you are upgrading from an older release, the recommended practice -is to start with a clean directory. Unpacking the newer release over an older -one will not clean up any old files, and trying to use the environment's -"Clean" command will probably not account for all existing files.

- -

For using MPC and our perl based test framework we recommend -our windows users to use Active -State Perl or Strawberry Perl

- - - -

-

Building and Installing ACE on Windows with -Microsoft Visual Studio

- -

ACE contains project files for -Visual Studio 2015 (vc14), Visual Studio 2017 (vc141), and Visual Studio 2019 (vc142). -Visual Studio 2015/2017/2019 use different file formats but the same file -suffixes (.sln and .vcproj). To support both -environments, ACE supplies files with different names for the different -development and target platforms. The platform/name mapping is shown below. -All solution files have a .sln suffix and all project files have -a .vcproj suffix.

- - - - - - - - - - - - - - - - - - - - - -
Mapping of Platform to Solution/Project File Name
PlatformFile Name
Visual Studio 2015name_vc14 -
Visual Studio 2017name_vs2017 -
Visual Studio 2019name_vs2019 -
- -

The VC++ compiler and linker can now be invoked from GNU make just like -most UNIX builds. Follow the instructions in the -ACE/GNU Configuration sections and see the additional information in the -comments of -platform_win32_msvc.GNU. -

- -

If you happen to open an older file Visual Studio solution from a newer one, it will offer to convert -the file to the newer format for you - -

    -
  1. Uncompress the ACE distribution into a directory, where it will - create a ACE_wrappers directory containing the distribution. The - ACE_wrappers directory will be referred to as ACE_ROOT in the - following steps -- so ACE_ROOT\ace would be C:\ACE_wrappers\ace if - you uncompressed into the root directory.
    -
    -
  2. Create a file called config.h in the ACE_ROOT\ace - directory that contains:
    -
    - #include "ace/config-win32.h"
    -
    - -
  3. The static, DLL and MFC library builds are kept in - different workspaces. Files with names *_Static contain project - files for static builds. Workspaces for static and DLL builds will be - available through the stock release at DOC group's website. The - workspaces for MFC are not available and have to be generated using - MPC. Please see MPC's README for - details.

    -
  4. Now load the solution file for ACE (ACE_ROOT/ACE.sln).
    -
    -
  5. Make sure you are building the configuration (i.e, Debug/Release) - the one you'll use (for example, the debug tests need the debug - version of ACE, and so on). All these different configurations are - provided for your convenience. You can either adopt the scheme to - build your applications with different configurations, or use - ace/config.h to tweak with the default settings on - NT.
    Note: If you use the dynamic libraries, - make sure you include ACE_ROOT\lib in your PATH whenever you run - programs that uses ACE. Otherwise you may experience problems - finding ace.dll or aced.dll.
    -
    -
  6. To use ACE with MFC libraries, also add the following to - your config.h file. Notice that if you want to - spawn a new thread with CWinThread, make sure you spawn the - thread with THR_USE_AFX flag set.
    -
    - #define ACE_HAS_MFC 1
    -
    - By default, all of the ACE projects use the DLL versions of the - MSVC run-time libraries. You can still choose use the static (LIB) - versions of ACE libraries regardless of run-time libraries. The - reason we chose to link only the dynamic run-time library is that - almost every NT box has these library installed and to save disk - space. If you prefer to link MFC as a static library into ACE, you - can do this by defining ACE_USES_STATIC_MFC in your - config.h file. However, if you would like to link - everything (including the MSVC run-time libraries) statically, - you'll need to modify the project files in ACE yourself.

    -

  7. Static version of ACE libraries are built with - ACE_AS_STATIC_LIBS
    defined. This macro should - also be used in application projects that link to static ACE - libraries
    -
    - Optionally you can also add the line
    -
    - #define ACE_NO_INLINE
    -
    - before the #include statement in ACE_ROOT\ace\config.h to disable - inline function and reduce the size of static libraries (and your - executables.)
    -
    -
  8. ACE DLL and LIB naming scheme:
    -
    - We use the following rules to name the DLL and LIB files in ACE - when using MSVC.
    -
    - "Library/DLL name" + (Is static library ? "s" : - "") + (Is Debugging enable ? "d" : "") - + {".dll"|".lib"}
    -
    -
- -

More information for ACE/TAO on MSVC can be found -here. The doxygen version of this -document is available under Related Topics in the ACE Library.

- -ACE TESTS

- -The tests are located in ACE_ROOT\tests. There is also a solution in -that directory to build all the tests (tests.sln)

- -Once you build all the tests (Batch Build works well for this), you -can run perl script run_test.pl in the -tests directory to try all the tests.

- - - BUILDING ACE ON A WIN32 MACHINE THAT LACKS A NETWORK CARD

- -You may want to run ACE on a non-networked machine. To do so, you must -install TCP/IP and configure it to ignore the absence of a network -card. This is one method: - -

    -
  1. Run Control Panel -
  2. Choose Network from Control Panel -
  3. Add Adapter: MS Loopback Adapter -
  4. Configure MS Loopback Adapter with 802.3 (default) -
  5. Add Protocol: TCP/IP Protocol -
  6. Configure TCP/IP Protocol with a valid IP address and subnet mask. - Leave everything else at the default settings. -
  7. Add Service: Workstation -
  8. Exit and Restart System -
  9. Run Control Panel again -
  10. Choose Services from Control Panel -
  11. The following services are not necessary and may - be set to Disabled Startup:
    - Alerter
    - Computer Browser
    - Net logon
    - Messanger
    -
  12. Choose Network from Control Panel -
  13. Confirm the following setup. This is all you need to run ACE:
    - Installed Software:
    - Computer Browser
    - MS Loopback Adapter Driver
    - TCP/IP Protocol
    - Workstation
    - Installed Adapter Cards:
    - MS Loopback Adapter

    -

- -

 

-

Building and Installing ACE on Windows with Embarcadero C++

- -If you are building for a machine without a network card, you may want -to check here first.

- -

    -
  1. Uncompress the ACE distribution into a directory, where it will - create an - ACE_wrappers directory containing the source. The ACE_wrappers - directory will be referred to as ACE_ROOT in the following steps -- so - ACE_ROOT\ace would be C:\ACE_wrappers\ace when you uncompressed into the - root directory.
    -
    -
  2. Create a file called config.h in the ACE_ROOT\ace - directory that contains at least:
    -
    - #include "ace/config-win32.h"
    -
    -
  3. Open a RAD Studio Command Prompt.
    -
    -
  4. Set the ACE_ROOT environment variable to point to the ACE_wrappers - directory. For example:
    -
    - set ACE_ROOT=C:\ACE_wrappers
    -
    -
  5. Add ACE_wrappers\lib and ACE_wrappers\bin to the PATH environment variable:
    -
    - set PATH=%ACE_ROOT%\lib;%ACE_ROOT%\bin;%PATH%
    -
    -
  6. Change to the ACE_ROOT\ace directory.
    -
    - cd %ACE_ROOT%\ace
    -
    -
  7. Generate the bmake makefiles using MPC. Use the bmake project type for C++ Builder:
    -
    - %ACE_ROOT%\bin\mwc.pl -type bmake
    -
    -
  8. You can build several different versions of ACE by setting the following optional environment - variables before you run make:
    -
    - Set the environment variable below to build a debug version of ACE
    - set DEBUG=1
    -
    - Set the environment variable below to build a unicode version of ACE
    - set UNICODE=1
    -
    - Set the environment variable below to build a version of ACE with - Codeguard support. Should only be used when DEBUG is also set
    - set CODEGUARD=1
    -
    - By default we are using the clang based compilers. At the moment you - want to compile using the old bcc32 compiler set the CLASIC environment variable
    - set CLASSIC=1
    -
    - Set the environment variable below to build a version of ACE optimized - for a certain CPU. For this there are special compiler flags - (-3/-4/-5/-6), see the Embarcadero help for more info.
    - set CPU_FLAG=-6
    -
    - You can then start the build with the command -
    make -f Makefile.bmak all
    -
    - You may also enable the options by passing them as command line options to make, for example:
    - make -f Makefile.bmak -DDEBUG all
    -
    -
  9. Build ACE by doing:
    -
    - make -f Makefile.bmak all
    -
    -
- -

- -Note that when you run make in a sub directory you give make -f Makefile.bmak all. The all is needed to make sure the complete project is build.

- -The C++ Builder port has been done by Jody Hagins, Christopher Kohlhoff and Johnny Willemsen.

- -ACE TESTS

- -Before you can build the tests you need to build the protocols directory. -Change the directory to ACE_ROOT\protocols and start:

-

-%ACE_ROOT%\bin\mwc.pl -type bmake
-make -f Makefile.bmak all -

- -The tests are located in ACE_ROOT\tests, change to this directory. -You build then the tests with the following commands:

-

-%ACE_ROOT%\bin\mwc.pl -type bmake
-make -f Makefile.bmak all -

- -Once you build all the tests, you can run the automated test script using:

-

perl run_test.pl

in the -tests directory to try all the tests. You need to make -sure the ACE bin and lib directory (in this case -%ACE_ROOT%\bin and %ACE_ROOT%\lib) -are on the path before you try to run the tests. If your executables are -compiled into a subdirectory, add -ExeSubDir subdirname to the -command.

- -

-

Building and Installing ACE on Win32 with MinGW/ MSYS

- -

-If you are building for a machine without a network card, you may want -to check here first. - -

-Building and installing ACE on MinGW -uses a mix of a UNIX building process and -Win32 configuration files. -Also, as MinGW uses GNU g++, you may want to take -a look at the Compiling ACE with GNU g++ section. - -

-You will need the MinGW build tools and libraries, downloable from -http://www.mingw.org. - -
-For our build we require the packages -MinGW and MSYS. - -

    - -
  1. Install the MinGW tools (including the MinGW Development toolkit) into a common directory, say c:/mingw. -

    - -
  2. Install the MSYS tools into a common directory, say c:/msys. -

    - -
  3. Open a MSYS shell. Set your PATH environment variable so - your MinGW's bin directory is first: - - 
           % export PATH=/c/mingw/bin:$PATH
-
    - -
  4. Add an ACE_ROOT environment variable pointing to the - root of your ACE wrappers source tree: - - 
           % export ACE_ROOT=/c/work/mingw/ACE_wrappers
-
    - - From now on, we will refer to the root directory of the ACE - source tree as $ACE_ROOT. -

    - -
  5. Create a file called config.h in the - $ACE_ROOT/ace directory that contains: - - 
           #include "ace/config-win32.h"
-
    - -
  6. Create a file called platform_macros.GNU in the - $ACE_ROOT/include/makeinclude directory containing: - - 
           include $(ACE_ROOT)/include/makeinclude/platform_mingw32.GNU
-
    - - In the above text, don't replace $(ACE_ROOT) with the - actual directory, GNU make will take the value from the - environment variable you defined previously. - -

    - If you lack Winsock 2, add the line - - 

           winsock2 = 0
-
    - - before the previous one. -

    - -

    - If you want to install ACE (using "make install") and want all the .pc files generated, - set the installation prefix in platform_macros.GNU. - 

          INSTALL_PREFIX=/c/ACE
-
    - Headers will be installed to $INSTALL_PREFIX/include, documentation and - build system files to $INSTALL_PREFIX/share and libraries to $INSTALL_PREFIX/lib. With INSTALL_PREFIX set, RPATH will be enabled. - To disable RPATH (for example, if $INSTALL_PREFIX/$INSTALL_LIB is already - a system-known location for shared libraries), set the make macro - install_rpath to 0 by adding install_rpath=0 to platform_macros.GNU. - -

    - -
  7. In the MSYS shell, change to the $ACE_ROOT/ace directory and - run make: - - 
           % cd $ACE_ROOT/ace
-       % make
-
    - -

    - This should create libACE.dll (the Win32 shared library) and - libACE.dll.a (the Win32 import library for the DLL). - Note that the name for the ACE DLL follows the MinGW convention, which itself - resembles UNIX. - -

    - If you want static libs also, you may run: - - 

           % make static_libs_only=1
-
    - -
  8. Run make install: - - 
           % make install
-
    -

    - This should create ACE.pc to use with pkg-config. -

    - -
  9. - The same rules for Win32 search of DLLs apply for MinGW. If you - want to run some ACE programs from the MSYS shell, you may - need to add the directory for libACE.dll to your PATH: - - 
           % export PATH=/c/work/mingw/ACE_wrappers/ace:$PATH
-
    - -
- -ACE TESTS

- -The tests are located in $ACE_ROOT/tests. -After building the library, you can change to that directory and run -make: - - 

       % cd $ACE_ROOT/tests
-       % make
-
- -

-Once you build all the tests, you can run -run_tests.pl in the -tests directory to try all the tests: - - 

       % perl run_test.pl
-
- -

-If you are using ACE as a DLL, you will need to modify your PATH -variable as explained above. - -

-You may want to check $ACE_ROOT/tests/README for the status -of the various tests on MinGW and the different Windows flavors. - -

-

Building and Installing ACE on Win32 with Cygwin

- -

-If you are building for a machine without a network card, you may want -to check here first. - -

-Building and installing ACE on Cygwin -uses the UNIX building process. -Also, as Cygwin uses GNU g++, you may want to take -a look at the Compiling ACE with GNU g++ section. - -

-You will need the Cygwin build tools and libraries, downloable from -http://www.cygwin.com. -For our build we require the following packages besides the packages the -setup selects by default: - -

-gcc (version 3.3.3), cygserver, make, perl, binutils. -
- -
    - -
  1. Install Cygwin (this can be easy downloading and running - setup.exe - from the Cygwin site). For working with ACE we recommend - to select DOS as default text file type. -

    - -
  2. Open a Cygwin shell. Set your PATH environment variable so - your Cygwin bin directory is first: - - 
           % export PATH=//c/cygwin/bin:$PATH
-
    - - or - - 
           % export PATH=/cygdrive/c/cygwin/bin:$PATH
-
    - -

    - Note Cygwin uses ``/'' as directory separator, - and ``//X'' as a notation for Win32 drive X. - Note also that you can't use ``c:/cygwin/bin'' - because, for Cygwin, - ``:'' is path separator character, as in UNIX. -

    - -

  3. Add an ACE_ROOT environment variable pointing to the - root of your ACE wrappers source tree (in this example c:/work/cygwin/ACE_wrappers): - - 
           % export ACE_ROOT=/cygdrive/c/work/cygwin/ACE_wrappers
-
    - -

    - Note here you can't use the ``//X'' Cygwin - notation as this is seen by Cygwin's compiler and it doesn't - support that (it does support ``/'' as directory - separator however). - -

    - From now on, we will refer to the root directory of the ACE - source tree as $ACE_ROOT. -

    - -

  4. Create a file called config.h in the - $ACE_ROOT/ace directory that contains: - - 
           #include "ace/config-cygwin32.h"
-
    - -
  5. Create a file called platform_macros.GNU in the - $ACE_ROOT/include/makeinclude directory containing: - - 
           include $(ACE_ROOT)/include/makeinclude/platform_cygwin32.GNU
-
    - - In the above text, don't replace $(ACE_ROOT) with the - actual directory, GNU make will take the value from the - environment variable you defined previously. - -
  6. On the Cygwin shell, change to the $ACE_ROOT/ace directory and - run make: - - 
           % cd $ACE_ROOT/ace
-       % make
-
    - -

    - This should create libACE.dll (the Win32 shared library) and - libACE.dll.a (the Win32 import library for the DLL). - Note the name for the ACE DLL on Cygwin follows the UNIX convention. -

    - -

    - If you want static libs also, you may run: - - 

           % make static_libs_only=1
-
    - -
  7. - The same rules for Win32 search of DLLs apply for Cygwin. If you - want to run some ACE programs from the Cygwin shell, you may - need to add the directory for libACE.dll to your PATH: - - 
           # export PATH=//c/work/cygwin/ACE_wrappers/ace:$PATH
-
    - - If you are using MPC-generated Makefiles, then the DLLs have been - placed in the lib directory instead of ace and thus your PATH - addition would need to look like this: - - 
           # export PATH=//c/work/mingw/ACE_wrappers/lib:$PATH
-
    - - -
- -ACE TESTS

- -The tests are located in $ACE_ROOT/tests. -After building the library, you can change to that directory and run -make: - - 

       % cd $ACE_ROOT/tests
-       % make
-
- -

-Once you build all the tests, you can run -run_tests.pl in the -tests directory to try all the tests: - - 

       % perl run_test.pl
-
- -

-If you are using ACE as a DLL, you will need to modify your PATH -variable as explained above. - -

-You may want to check $ACE_ROOT/tests/README for the status -of the various tests on Cygwin and the different Windows flavors. -

- -

-
- -

-

Building and Installing ACE on Win32 with Interix

-

Interix comes with a BSD style make; you need GNU make. -Make builds easily under Interix or there is a prebuilt -package at:

-

http://www.interopsystems.com/tools/warehouse.htm

-

If you are building for a machine without a network -card, you may want to check here first.

-

This port was built and tested under Interix 3.5. a.k.a. -Windows -Services for UNIX 3.5.

-

To build follow the Traditional ACE/GNU Make -Configuration instructions replacing the following include directives:

-

#include -"ace/config-win32-interix.h"

-

for the config.h header

-

and:

-

include -$(ACE_ROOT)/include/makeinclude/platform_win32_interix.GNU

-

for your platform_macros.GNU file.

-

ACE should build fine with just 'make', the only other option tried thus far is -'make static_libs_only=1' which also works. Any -other options may not work.

-

ACE TESTS

-

The tests are located in $ACE_ROOT/tests. After building the library, you can -change to that directory and run make:

-

% cd $ACE_ROOT/tests
% make -

Once you build all the tests, you can run run_test.pl in the tests directory to try all the tests:

-

% run_test.pl

-

If you are using ACE as a shared library, you will need -to modify your LD_LIBRARY_PATH as explained inTraditional ACE/GNU Make Configuration.

-

- -

-

Building and Installing ACE on VxWorks

-For the most part, you should be able to follow the instructions above -to build ACE and applications that use it. Start with the -Unix instructions above to build ACE and the -applications that use it. Please see below for more information on -building ACE on NT hosts for VxWorks targets.

- -A few notes on VxWorks builds (thanks to -Paul von Behren and -Remedy IT for these notes):

-

-

- -You'll have to let ACE know the target type at compile time. There -are several ways to do this; please see the -$ACE_ROOT/include/makeinclude/platform_vxworks5.5.x.GNU -platform file for detailed information.

- -The VxWorks platform_vxworks*.GNU files are set up so that shared -libraries are not built on VxWorks, by default. Only static -libraries, with .a extension, are built. Therefore, it's not -necessary to set the LD_LIBRARY_PATH environment variable on your host -system when building for VxWorks targets. Please note, however, if -you use TAO on VxWorks that you will need to set your LD_LIBRARY_PATH -to find the TAO IDL compiler libraries (installed in the ace -directory) on the host.

- -These non-default VxWorks kernel configuration #defines -are required with ACE:

- -

#define INCLUDE_CPLUS           /* include C++ support */
-#define INCLUDE_CPLUS_IOSTREAMS /* include iostreams classes */
-#define INCLUDE_POSIX_ALL       /* include all available POSIX functions */
-
- -For completeness, here are the non-default #defines that -we used for VxWorks 5.3.1/g++ 2.7.2: - -
#define INCLUDE_CPLUS           /* include C++ support */
-#define INCLUDE_CPLUS_IOSTREAMS /* include iostreams classes */
-#define INCLUDE_CONFIGURATION_5_2 /* pre-tornado tools */
-#define INCLUDE_DEBUG           /* pre-tornado debugging */
-#define INCLUDE_LOADER          /* object module loading */
-#define INCLUDE_NET_SYM_TBL     /* load symbol table from network */
-#define INCLUDE_SYM_TBL_SYNC    /* synchronize host and target symbol tables */
-#define INCLUDE_NFS             /* nfs package */
-#define INCLUDE_PING            /* ping() utility */
-#define INCLUDE_POSIX_ALL       /* include all available POSIX functions */
-#define INCLUDE_RDB             /* remote debugging package */
-#define INCLUDE_RLOGIN          /* remote login */
-#define INCLUDE_RPC             /* rpc package */
-#define INCLUDE_SECURITY        /* shell security for network access */
-#define INCLUDE_SHELL           /* interactive c-expression interpreter */
-#define INCLUDE_SHOW_ROUTINES   /* show routines for system facilities*/
-#define INCLUDE_SPY             /* spyLib for task monitoring */
-#define INCLUDE_STARTUP_SCRIPT  /* execute start-up script */
-#define INCLUDE_STAT_SYM_TBL    /* create user-readable error status */
-#define INCLUDE_SYM_TBL         /* symbol table package */
-#define INCLUDE_UNLOADER        /* object module unloading */
-#define INCLUDE_WINDVIEW        /* WindView command server */
-
- -Also, automatic construction/destruction of static objects -should be enabled.

- -If you use TAO, it's also a good idea to increase the -NUM_FILES parameter from its default of 50 to, -say, 1000.

- -Please note that those VxWorks kernel configuration parameters -are set in the VxWorks configAll.h file. You must rebuild your -VxWorks kernel after modifying that file.

- -If you're first getting started with ACE and/or VxWorks, I recommend -just building the ACE library and tests first. (Some of the ACE -examples, in System_V_IPC, don't build on VxWorks yet.) Then try -running the tests. Please see $ACE_ROOT/tests/README for the latest -status of the ACE tests on VxWorks.

- -Please note that the main entry point is renamed to -ace_main (configurable via ACE_MAIN) on VxWorks with g++, -to comply with its restriction against using main. -In addition, ACE_HAS_NONSTATIC_OBJECT_MANAGER is enabled by default -to cleanly support construction and destruction of static objects. -Please see the Non-static -ACE_Object_Manager discussion for the important implication -of this feature.

- -ACE threads (VxWorks tasks) can be named, for example, by supplying a -non-null argument to the Thread_Manager spawn routines. However, -names beginning with "==ace_t==" are forbidden because -that prefix is used internally by ACE.

- -You can spawn a new task to run ace_main, using either -VxWorks sp, or ACE'S spa. -spa can be used from the VxWorks shell to pass arguments -to ace_main. Its usage is: - -


-spa ace_main, "arg1" [, ...]
-
- -All arguments must be quoted, even numbers. You can start also ace_main -without spawning another thread by using:

- -


-spaef ace_main, "arg1" [, ...]
-
- -ACE also provides the function vx_execae which is capable of running -ace_main in a separate thread, wait for the task to finish and return -the return code from ace_main: - -

-int vx_execae (FUNCPTR acemain,char* arguments, int prio = 0, int opt = 0, int stacksz = 0);
-
-

-You could call this from the VxWorks shell like: -

-

-my_rc = vx_execae ace_main, "-o server.ior -ORBDottedDecimalAddresses 1"
-

- -When prio, opt or stacksz are omitted or specified -as 0 default values will be used. See the VxWorks shell documentation for the -defaults for prio and opt. For stacksz the default is -ACE_NEEDS_HUGE_THREAD_STACKSIZE. -The arguments string will be parsed and passed on to ace_main as -a regular argc and argv.

- -Be aware of the fact that when you execute ace_main directly from the VxWorks -shell argc will be zero and argv* will also be zero. Using argv[0] will not return -the program name, but will result in a crash.
-The ACE helper functions spa, spaef and vx_execae prevent -this problem by building a regular argc and argv which also contain a -valid argv[0] element.

- -

Building Shared Libraries for VxWorks.

- -NOTE: Since VxWorks support is currently being reworked with -an initial focus on static builds the support for shared builds is momentarily -broken. This will be remedied(!) as soon as possible.

- -ACE supports shared libraries for VxWorks, but only with the g++ -compiler. To build shared libraries instead of the default static -libraries, added shared_libs_only=1 to either your -ACE_wrappers/include/makeinclude/platform_macros.GNU or -your make invocation. Then, be sure to load the ACE (and -any other) shared library before loading your executable(s).

- -A shared library for VxWorks uses the same code as for a static -(non-shared) library. However, calls to static constructors/ -destructors are added. The code in the shared library must -be reentrant if you shared it between programs (tasks). The -ACE library meets this requirement.

- -Shared libraries reduce build time, executable size, and load -time of the executable. But, you must manually load the shared -library before loading your executable(s) with a command such as: -


--> ld < libACE.so
-
-Shared libraries can be unloaded the same way an executable -(module) is unloaded.

- -NOTE: Shared libraries on VxWorks aren't the same as -shared libraries on other operating systems. In particular, there is -no support for creating copies of writeable global (static) data in -the shared library. This includes the singleton ACE_Object_Manager -instance pointer. If you share global data between separate programs, -they may not work properly. See the discussion of shared code and -reentrancy in the VxWorks' Programmers Guide.

- -Instead of trying to run separate programs onto a VxWorks target, we -recommend creating just one program, and spawning a thread for each -task. The TAO IDL_Cubit test collocation -test is a good example.

- -

Linking ACE and/or TAO Libraries into the VxWorks Kernel.

- -It's easy to link your ACE and/or TAO libraries into the VxWorks kernel. -Just build shared versions, but -disable the munch step. The easiest way to do that is to set the -LD make variable to the name of your linker. For -example, to build a libACE.so for PowerPC that can be linked into -the kernel: -
% cd $ACE_ROOT/ace
-% make LD=ldppc shared_libs_only=1
-
-After building the shared lib, link it into the kernel by setting -the MACH_EXTRA make variable in the kernel configuration -Makefile. Then, build the kernel using make exe.

- -

Using the one-button ACE tests with VxWorks.

- -It is possible to generate a script to execute all ACE tests. You can do this by executing -

% perl run_test.pl -v -o > run_test.vxworks
-
- -The ACE tests write their output files in a directory named -log/, below the current (tests) directory.
-

-

-To run the tests from the build directory on an NT host where you crossbuild your -VxWorks ACE/TAO you can set up the Target Server File System (TSFS) in your Target Server -configuration. If you f.i. set the root for the TSFS to the root directory of your builddisk -you can set the default directory for the target by issueing the following command -from a Host shell: '@cd "/tgtsvr/{path to ACE}/ACE_wrappers/tests"'. -The '@' addition makes sure this command is executed for the target environment and not the -local host shell environment. -If you also issue the command 'cd {path to ACE}/ACE_wrappers/tests' you can execute the -generated one button testscript like: '< run_test.vxworks'. -

-

-Running the ACE tests automatically from the ACE autobuild tool using Target Server and Host -shell options is also supported. -

-

-If you don't have NFS included in your VxWorks kernel, you can use these steps, provided by -Clarence M. Weaver, -to run the tests and capture their output:

-

    -
  1. What I did was create a log directory on the boot NT host of my VxWorks - target.

    -

  2. I copied all the test applications and the run_test.vxworks script to - the parent of the log directory.

    -

  3. Using the target shell not the host shell, I "cd" to the directory - containing the script and test programs.

    -

  4. Invoked the script using < run_test.vxworks from this target shell.

    -

- -Kirk Davies provided this -approach for running the ACE tests on Tornado II: - - - -

Building ACE on Tornado/NT hosts for VxWorks targets.

-The following, very useful information was contributed by -Chris Ryan -and Paul von Behren. -Please submit corrections, additions, or clarifications to the -the ACE mailing list.

- -NOTE:The make (version 3.74) that is provided with -Tornado 2.2 cannot be used to build ACE. A working version is available -from the WindRiver support site, download the - -make3_80.gvk_patches and the - -make3_80.tor2_2.new_dependency_rules package and install them.

- -Using the Cygnus tools, this approach works: -

- -A few additional Windows Notes, from Paul von Behren:

-

- -And Chris Ryan's instructions for building for VxWorks targets -on Windows NT hosts: - -
    -
  1. Path setting that seems to be working is:

    - 

          /tornado/host/x86-win32/bin:
-      /tornado/host/x86-win32/lib/gcc-lib/i386-wrs-vxworks/cygnus-2.7.2-960126:
-      /tornado/host/x86-win32/i386-wrs-vxworks/bin:
-      /ace/ace_wrappers/bin:
-      /gnuwin32/b18/H-i386-cygwin32/bin:
-      /gnuwin32/b18/tcl/bin:
-      /WINNT/system32:
-      /WINNT:
-      /WINNT/system32/nls/ENGLISH:
-      /bin
-
    - - Other environment variables:

    - 

          WIND_BASE=/tornado
-      SHELL=/bin/sh.exe
-      TERM=pcbios
-      TAO_ROOT=/ace/ACE_wrappers.vxworks/TAO
-      CPP_LOCATION=/Program Files/DevStudio/VC/bin/CL.EXE
-      GCC_EXEC_PREFIX=/tornado/host/x86-win32/lib/gcc-lib/
-      WIND_HOST_TYPE=x86-win32
-      ACE_ROOT=/ace/ACE_wrappers.vxworks
-
    - -
  2. /tornado is the root of the Tornado install - ($WIND_BASE). - -
  3. /gnuwin32 is the root of a Cygnus GNU download and install. - -
  4. /bin content is:

    - 

          aced.dll
-      cygwin.dll
-      perl.exe
-      rm.exe
-      sh.exe
-      true
-
    - - aced.dll is produced in an ACE NT source tree according to - documented procedure for Windows VC++ ACE build. - - cygwin.dll is from the Cygnus GNU software download and install. - -
  5. Basically, follow documented procedure for ACE build/install on UNIX - platform. Create a $ACE_ROOT/ace/config.h that looks - like:

    - 

          #include "config-vxworks5.x.h"
-
    - - And create a - $ACE_ROOT/include/makeinclude/platform_macros.GNU - that looks like:

    - 

    -      WIND_BASE = /tornado
-      WIND_HOST_TYPE = x86-win32
-      CPU = I80486
-      include $(ACE_ROOT)/include/makeinclude/platform_vxworks5.5.x.GNU
-
    - -
  6. When using cygnus windows GNUTools on WinNT you have to start - make with "--unix" option, otherwise WinNT shell cmd.exe is responded and - not sh.exe, i.e., - 
     make --unix static_libs_only=1
-
    -
- -

TAO on NT Tornado host, VxWorks target.

- -
    -
  1. Build ACE and TAO_IDL in the NT tree as already documented. - Be sure to build ACE's gperf on NT, in - ACE_wrappers/apps/gperf/src.

    - -

  2. Build $TAO_ROOT/tao - 
          CPP_LOCATION=/Program Files/DevStudio/VC/bin/CL.exe
-      cd $TAO_ROOT/tao
-      /gnuwin32/b18/H-i386-cygwin32/bin/make
-
    - -
  3. Build orbsvcs. - 
          CPP_LOCATION=/Program Files/DevStudio/VC/bin/CL.exe
-      cd $TAO_ROOT/orbsvcs/orbsvcs
-      /gnuwin32/b18/H-i386-cygwin32/bin/make
-
    - -
  4. Build $TAO_ROOT/tests

    -

- - -

Jaffar Shaikh's -Notes for Building ACE and TAO for VxWorks on NT host

-

Scenario: I was building the ACE and TAO for VxWorks -on NT. The target system was a PPC860 based chassis and another a NT -host based card.

-

Host System:

-

NT 4.0 workstation with 128 M RAM, 266MHz Pentium.

- -

Software Needed For Building TAO

-

1) ActiveState Perl -or Strawberry Perl -

- -

2) Tornado 2.2.1 from Windriver.

- -

3) Cygwin GNU to build TAO. It is available for NT as a freeware -from the Cygwin site

-

The Cygwin Make (version 3.75) can only build the TAO not the -Tornado II make (version 3.74)

- -

Environment Variables:

-

On NT the environment Variables are set as follows, (from -Control Panel-> System -> Environment)

-

I added following Environment variable entries to PATH

- -
-C:\Perl\bin\;
-C:\tornado\host\x86-win32\bin;
-C:\tornado\host\x86-win32\powerpc-wrs-vxworks\bin;
-C:\tornado\host\x86-win32\lib\gcc-lib\powerpc-wrs-vxworks\cygnus-2.7.2-960126;
-C:\Corba\Ace_wrappers\bin;
-C:\Cygwin\bin;
-C:\Cygwin\usr\bin;
-C:\bin
-
- -

Additional Environmental variables and the values,

-
-CPU=PPC860
-LD_LIBRARY_PATH=
-SHELL=/bin/sh.exe
-ACE_ROOT=/Corba/ACE_wrappers
-WIND_BASE=/tornado
-SHELL=/bin/sh.exe
-TERM=pcbios
-TAO_ROOT=/Corba/ACE_wrapper/Tao
-CPP_LOCATION=/Program Files/Microsoft Visual Studio/VC98/Bin/CL.exe
-GCC_EXEC_PREFIX=/tornado/host/x86-win32/lib/gcc-lib/
-WIND_HOST_TYPE=x86-win32
-PERL_PATH=/perl/bin/perl.exe
-
- -

Directories of importance

-

C:\Corba <-- Ace_wrappers (uzipped)

-

C:\tornado <-- Tornado installed

-

C:\Perl <-- Perl installed

-

C:\Cygwin <-- Cygwin installed

-

C:\bin <-- Copy these files,

-

Ace.dll, <-- After you build Ace

-

gperf.exe <-- After you build gperf

-

Cygwin1.dll, <-- After you install Cygwin

-

perl.exe, <-- After you install Perl

-

rm.exe <-- After you install Cygwin

-

sh.exe <-- After you install Cygwin

-

true <-- After you install Cygwin

-

Create Files

-

1) C:\Corba\ACE_Wrappers\ace\config.h

-

with entry

-
-#if defined (_MSC_VER) || (__BORLANDC__)
-  #include "ace/config-win32.h"
-#else
-  #define ACE_HAS_IP_MULTICAST
-  #include "ace/config-vxworks5.x.h"
-#endif
-
- -

2) C:\Corba\ACE_wrappers\include\makeinclude\platform_macros.GNU

-
-WIND_BASE = /tornado
-WIND_HOST_TYPE = x86-win32
-include $(ACE_ROOT)/include/makeinclude/platform_vxworks5.5.x.GNU
-ACE_COMPONENTS=FOR_TAO (you may choose this option to build ACE library that supports TAO)
-
- -

-

Steps to Build

-

1) Build Ace.dll under NT

-

In MS Visual C++ open C:\Corba\ACE_wrappers\ace.sln And build Ace -DLL

-

Copy Ace.dll in C:\bin

- -

2) Build gperf utility under NT

-

In MS Visual C++ open -C:\Corba\ACE_wrappers\apps\gperf\src\gperf.sln. Build gperf.exe

-

Copy gperf.exe to C:\bin

- -

3) Mount Directries in Cygwin

-

Click on Cygnus Solutions -> Cygwin Bash Shell

-

Mount following directories by using mount command.

-

create respective directories first then use mount command

- -

e.g. Create /Corba directory then use $mount -s "C:\Corba" -/Corba

- -

C:\Corba mount to /Corba

-

C:\tornado mount to /tornado

-

C:\Perl mount to /perl

-

C:\Cygwin mount to /cygwin

-

C:\bin mount to /bin

-

C:\Program Files mount to /Program Files

- -

4) Build ACE in Cygwin

-

$cd /Corba/ACE_wrappers/ace

-

$make static_libs_only=1

-

This will build your ace library libACE.a for VxWorks. If you use -option shared_libs_only=1 then the build will be libACE.so. The other -options are same as follows.

- -

5) Build TAO in Cygwin

-

$cd $TAO_ROOT/tao

-

$make debug=0 optimize=1 static_libs_only=1 minimum_orb=1 -

-

for shared libs use shared_libs_only=1

- -

The minimum Tao does not have following components,

-

Dynamic Skeleton Interface

-

Dynamic Invocation Interface

-

Dynamic Any

-

Interceptors

-

Interface Repository

-

Advanced POA features

-

CORBA/COM interworking

- -

You may play around with above options to find suitable build for -your needs. For example when you give option debug=1 all the debug -symbols will be created and the build will huge in size. The debug -symbols are necessary when you want to debug your code.

- -
- -

Building and Installing ACE on Android

- - - -

ACE can be built for Android by using the Android Native Development Kit -(NDK). This is different than the standard way of writing Android -applications in Java which run the on Android Runtime or the older Dalvik -Virtual Machine. Applications built using the NDK are native Linux applications -written in C or C++ specifically compiled to run on Android systems. In -addition, applications built using the NDK have access to Android-specific APIs -much like the ones available to Java-based Android applications. -

- -
-

Windows Users: These instructions are written for a Unix based -platform like Linux, but can also be used on Windows. If you are using an -virtualized Linux environment like Windows Subsystem for Linux (WSL), Docker, -or a traditional VM, then you can use the Linux version of the NDK and ignore -rest of this note and all the other Windows specific notes. -

- -

If that is not the case, you should also pay attention to the notes marked -with "Windows Users:" in addition to the rest of the instructions. In -addition to the Windows version of the Android NDK, you will also need -MSYS2 for Unix utilities that ACE needs. -

- -

Generating a Toolchain

- -

To build ACE for Android you need to download the NDK and generate a -toolchain for the specific Android target you want. The specific target is -defined by two things:

- -
-
- The minimal API level to target.
-
A lower level means larger amount of potential users but also - potentially less features. Android has many API levels - to target. They roughly correspond to the versions of Android. -
-
- The CPU architecture to target (Also called the Application Binary - Interface or ABI by the NDK documentation).
-
In addition to ARM, Android also supports x86 and MIPS, - although support for MIPS has been dropped from the NDK. This is the official - documentation on the ABIs. These are the ABIs that ACE supports at the - time of writing and must be passed to ACE as ANDROID_ABI: - -
-
armeabi-v7a
-
32-bit ARM, The default ABI for both the NDK and ACE.
-
armeabi-v7a-with-neon
-
armeabi-v7a with NEON extensions enabled.
-
arm64-v8a
-
64-bit ARM, Sometimes referred to as aarch64.
-
x86
-
32-bit x86
-
x86_64
-
64-bit x86
-
-

- It should be noted that starting in August 2019, the Google Play - Store will require new apps to have 64-bit libraries if they have native - libraries. 32-bit native libraries will still be supported but they must also - have 64-bit libraries. Look up any restrictions that may affect - apps you want to publish on the Play Store, including minimum API - level. -

-
- -
- - -

To generate a toolchain, one use must use -build/tools/make_standalone_toolchain.py in the NDK. A destination must be -chosen and is denoted here as $TOOLCHAIN. For example, to generate a -toolchain targeting 32-bit ARM Android 7.0 "Nougat" (API Level 24) and later:

-

-./make_standalone_toolchain.py --arch arm --api 24 --install-dir $TOOLCHAIN -

-

$TOOLCHAIN/bin must be in your $PATH when building ACE and -applications using ACE.

- -

This table shows how the ANDROID_ABI variable and the --arch argument correlate:

- - - - - - - - - - - - - - - - - - - - - - - - - -
ANDROID_ABI--arch
armeabi-v7aarm
armeabi-v7a-with-neonarm
arm64-v8aarm64
x86x86
x86_64x86_64
- -
-

Windows Users: -Android NDK includes Python in prebuilt\windows-x86_64\bin for -64-bit Windows NDKs. For the example above, assuming %NDK% is the -location of the NDK and %TOOLCHAIN% is the desired location of the -toolchain, run this command instead:

- -

- - %NDK%\prebuilt\windows-x86_64\bin\python.exe - %NDK%\build\tools\make_standalone_toolchain.py - --arch arm --api 24 - --install-dir %TOOLCHAIN% -

- -

For Windows %TOOLCHAIN%\bin and the location of the MSYS2 -utilities must be in %PATH% when cross compiling ACE. The default -location for these would be C:\msys64\usr\bin. -

- - -

Using Older NDKs

- -

Skip this section if using NDK r18 or later.

- -

-It is highly recommended to use the latest NDK available assuming -that it works with ACE. It is possible to use NDKs older than r18, but these -have caveats: -

- - -

Building

- - -

- -

Installing ACE on Android

- -

Native applications using the ACE library can be installed onto devices by -several different methods. The files can be include as assets of Java -application and can be written by the Java application into it's executable -program directory. The native application can be downloaded by a Java -application and written into the Java applications executable program -directory. The native application can also be uploaded using the Software -Development Kit's ADB tool. This method requires uploading the native -application to a directory that allows execution and having any output -directed to a writable directory.

- -

Logging

-

-On Android, ACE_Log_Msg (and therefore ACE_DEBUG and -ACE_ERROR) uses Android's logging system (aka Logcat) by default -in addition to stderr because stdout and -stderr are discarded under normal circumstances. To disable this -at runtime, run: -

- -
-ACE_LOG_MSG->clr_flags (ACE_Log_Msg::SYSLOG);
-
- -

To disable this at compile time include these lines in config.h:

- -
-#define ACE_DEFAULT_LOG_FLAGS ACE_Log_Msg::STDERR
-#define ACE_DEFAULT_LOG_BACKEND_FLAGS 0
-
- -

OpenSSL

-

- Depending on the features of ACE, TAO, or other software desired, you might need - OpenSSL. On Android, OpenSSL isn't part of the NDK Library and Android - preloads the system SSL library (either OpenSSL or BoringSSL) for the Java - Android API. This means OpenSSL MUST be statically linked to avoid - conflicts with the almost certianly incompatible system SSL library. - - To build OpenSSL for Android, please read NOTES.ANDROID that comes - with OpenSSL's source code. The static libraries will used if the shared - libraries are not found. This can be accomplished by either disabling the - generation of the shared libraries by passing no-shared to - OpenSSL's Configure script or just deleting the so files after - building OpenSSL. -

- -
-

Building and Installing ACE Network Services

- -The following explains how to build the ACE network services on UNIX and Win32. - -

-

Building and Installing ACE Network Services on UNIX

- -Building and installing ACE Network Services on UNIX is relatively -simple (the process for Win32 is different). -Here's what you need to do:

- -

    - -
  1. Build and install ACE on UNIX as described earlier. If ACE is built at the root of the ACE - source tree (and ACE has been ported to your platform, of course) the - netsvcs static and shared object libraries should be built - automatically. In addition, the server driver program - (main) contained in $ACE_ROOT/netsvcs/servers/main.cpp - should also be compiled and ready to run.

    - -

  2. Set your LD_LIBRARY_PATH environment variable to - where the binary version of the ACE netsvcs library. For - example, you probably want to do something like the following

    - - 

    
-      % setenv LD_LIBRARY_PATH $ACE_ROOT/ace:$ACE_ROOT/lib:$LD_LIBRARY_PATH
-

    - -

  3. By default, if the shared object library is built, the services - are linked into the main driver program dynamically. - To specify which services should be linked in and executed, edit the - $ACE_ROOT/netsvcs/servers/svc.conf - file. During your editing, you should update information (such as the - default service port numbers) that affects the initialization of - services in this file. Refer to the - Service Configurator - documentation to learn how the configuration file is parsed and - how the services are dynamically linked and executed. In - addition, refer to the Network - Services documentation to learn more about how to configure - each network service.

    - -

  4. If you only want to link the services statically, simply remove - or rename the svc.conf file.

    -

- -

-

Building and Installing ACE Network Services on Win32

- -Once again, there are supplied project for Visual C++ 7.1 or later for -the Network Services.

- -

-

Building and Installing the ACE_SSL Library

- -

The first step for all platforms is to build and install the -OpenSSL distribution. The -ACE_SSL library must then be built according to the instructions -below.

-

Unix

-
    -
  1. Make sure the OpenSSL header file directory is in your compiler's - include path, and that OpenSSL libraries are in your library link/load - path (e.g. LD_LIBRARY_PATH). If you - installed OpenSSL into a set of directories unknown by the compiler, - set the SSL_ROOT environment variable to point to the - top level directory of your OpenSSL distribution, i.e. the one - containing OpenSSL's include and lib - directories.
    2. -
  2. Build ACE as described above. When building ACE, add - ssl=1 - to your make - command line invocation, or add it to your - platform_macros.GNU file.
    3. -
  3. Build the ACE_SSL library in the $ACE_ROOT/ace/SSL - directory. The ACE_ROOT environment variable should be set - prior to this point.
    4. -
-

Microsoft Visual Studio

-
    -
  1. Set the SSL_ROOT environment variable to the location - of the directory containing the OpenSSL inc32 and - out32dll directories. -
  2. Add ssl=1 to your MPC - $ACE_ROOT/bin/MakeProjectCreator/config/default.features - or $ACE_ROOT/local.features file. -
  3. At the moment you are using OpenSSL v1.1 or - newer also add openssl11=1 to your MPC - $ACE_ROOT/bin/MakeProjectCreator/config/default.features - or $ACE_ROOT/local.features file. -
  4. Re-run MPC to add - support for building the ACE_SSL library to your MSVC++ - workspaces and projects. -
  5. Open the ACE.sln solution, and refer to the ACE build - and installation instructions above for details on creating a - config.h configuration header for this platform. Once - the config.h file has been created, build the - ACE_SSL project.
    6. -
-

Embarcadero C++

-

Support for building ACE's ACE_SSL library and TAO's SSLIOP - pluggable protocol with Embarcadero C++ does exist. -

    -
  1. Set the SSL_ROOT environment variable to the location - of the directory containing the OpenSSL inc32 and - out32 directories. -
  2. Add ssl=1 to your MPC - $ACE_ROOT/bin/MakeProjectCreator/config/default.features - or $ACE_ROOT/local.features file, and re-run MPC to add - support for building the ACE_SSL library to your Embarcadero C++ makefiles. -
  3. Build ACE and TAO. -
-

- -

-

Building and Using GUI Reactors Libraries

-There is a general method for building and using ACE_Reactors for various GUI -libraries. -

Building GUI Reactor Library

-
    -
  1. Try to generate build files using MPC. Inspect the output of MPC to find out which features are - necessary to build given reactor. Add these features to - ACE_wrappers/bin/MakeProjectCreator/*.features file, or pass them directly to MPC - using -features command line option. For example, for FlReactor the procedure - consists of five steps -
      -
    1. In the first pass one gets that x11 (X11 libraries) is missing.
      - $ mwc.pl -type gnuace - Skipping ACE_FlReactor (ace_flreactor.mpc), it requires x11. -
      2. - Ensure that X11 libraries are installed, then pass x11=1 feature to MPC. -
    2. In the second pass one gets that gl (OpenGL library) is missing.
      - $ mwc.pl -type gnuace -features x11=1 ace.mwc - Skipping ACE_FlReactor (ace_flreactor.mpc), it requires gl. -
      3. - Ensure that OpenGL libraries are installed, then pass gl=1 feature to MPC. -
    3. In the third pass one gets that fl (Fast Light Toolkit) is missing.
      - $ mwc.pl -type gnuace -features x11=1,gl=1 ace.mwc - Skipping ACE_FlReactor (ace_flreactor.mpc), it requires fl. -
      4. - Ensure that Fast Light Toolkit libraries are installed, then pass fl=1 - feature to MPC. -
    4. In the fourth pass one gets that ace_flreactor feature is missing
      - $ mwc.pl -type gnuace -features x11=1,gl=1,fl=1 ace.mwc - Skipping ACE_FlReactor (ace_flreactor.mpc), it requires ace_flreactor. -
      5. - Allow MPC to generate makefiles for FlReactor by setting ace_flreactor=1 feature. -
    5. In the last pass one obtains files for building FlReactor.
      - $ mwc.pl -type gnuace -features x11=1,gl=1,fl=1,ace_flreactor=1 ace.mwc -
      6. -
    - Currently to simplify MPC generation some of features are turned on by default in - ACE_wrappers/bin/MakeProjectCreator/global.features. For examples to generate - files related with Fl one has to provide only fl=1 feature. To obtain a more fine grained controll - over MPC generation process one may modify ACE_wrappers/bin/MakeProjectCreator/*.features - files. -
    2. -
  2. Required build files are generated now, it is enough then to invoke build tool. - For example for under MPC::gnuace one has to call - make fl=1. For MPC::vc7 target all features are - encoded in generated project files, thus it is enough to compile ACE using MSVC. -
    3. -
- The build procedure leads to a specific GUI Reactor library. For example, for - Qt and Linux one gets libQtReactor.so, while for - Windows the results are shared QtReactor.dll and import - QtReactor.lib libraries or their variants depending on build options. - When compiling TAO also GUI related libraries are created like libTAO_QtResource.so. -

Using GUI Reactor Library

- Here one has at least three use cases: -
    -
  1. Applications with their own build system. - To use ACE support for GUI one has to include specific GUI headers and - link with specific ACE_[GUI]Reactor library. When using TAO support for GUI one has - also to link with specific TAO_[GUI]Resource library.
    2. -
  2. Applications with build system using MPC. - In general, it is better to create specific base projects for using ACE GUI support in such application. - Base projects provided by ACE ACE_wrappers/bin/MakeProjectCreator/[ace,tao]_[gui][reactor,resource].mpb - may be an examples of how to do this.
    3. -
  3. Internal ACE applications like tests or examples. - MPC project for internal ACE application using GUI support should be derived from - ace_[gui]reactor.mpb base projects. To employ TAO support for GUI one should derive - the project from tao_[gui]resource.mpb These base projects ensure that all necessary libraries - are linked to the application, specifies features necessary to build a project and moreover impose a - build order consistant with ACE. For example, the application project using XtReactor should be - derived from ace_xtreactor.mpb.
    4. -
-

Notes on specific GUI Reactors

- - -
-

Installation Notes

- - - - -
-

Compiling ACE with GNU g++

- -If you use the GNU GCC g++ compiler please note the following: - - - - -

-

What Do I Need to Build for TAO?

-Toshio Hori <toshi@etl.go.jp> provided these suggestions on building -just what's needed for (a subset of) TAO:

- -I usually make: -

    $ACE_ROOT/ace,
-    $ACE_ROOT/apps/gperf,
-    $TAO_ROOT/tao,
-    $TAO_ROOT/TAO_IDL, and
-    $TAO_ROOT/orbsvcs/orbsvcs
-
-and the whole make takes less than an hour on my Solaris 7 for intel, -Pentium-III/550MHz, 256MB memory, 512MB swap machine. (Top secret: I -renice the 'make' process to the highest priority, -20... ;-) - -To save time and space, I set -
    TAO_ORBSVCS = Naming Time Trader ImplRepo
-
-in $ACE_ROOT/include/makeinclude/platform_macros.GNU also. See -TAO's orbsvcs -library customization instructions for more information.

- - -

System Resource -Requirements

The amount of system resources required to build -ACE and TAO varies greatly. The required system resources are -influenced by OS and compiler platform, build options, and component -configurations. As a rough guide, the typical peak memory requirement -can be well over 512 MB (notably, for TAO's orbsvcs). Depending on -your OS and compiler configuration, an entire build -of ACE and TAO can use well over 4 GB of disk space. It's usually not -necessary to build all of ACE and TAO, though.

- -Much less disk space is required for just the libraries. For example, -see the ACE -library subset sizes.

- -If you run out of memory when building, you might consider trying -some or all of these suggestions:

-

- -

-

General MPC information

- -

-The -Makefile Project Creator (MPC) is a tool that takes platform and -building tool generic files (mpc files) as input, which describe basic -information needed to generate a "project" file for various build -tools, including Make, NMake, Visual C++ 6, Visual C++ 7, etc. Please -see USAGE, README for documentation on MPC. -

- -

-A common usage for creating a Windows workspace containing just the -core ACE and TAO libraries and executables is the following: -

- -

-C:> cd %TAO_ROOT%
-C:> %ACE_ROOT%\bin\mwc.pl -type vc71 TAO_ACE.mwc
-
- -

-Replace vc71 with whatever project type you want to use. On Linux and -other UNIX platform use the gnuace type: -

- -

-% cd $TAO_ROOT
-% $ACE_ROOT/bin/mwc.pl -type gnuace TAO_ACE.mwc
-
- -

-This creates the appropriate GNUmakefiles. Additional information on -how to obtain, configuration, and build ACE+TAO using MPC appear at -the OCI FAQ. -

- -

-If you are attempting to generate project files using MPC, and you get -the following error message: -

- -
ERROR: Unable to find the MPC modules in /builds/ACE_wrappers/MPC.
-You can set the MPC_ROOT environment variable to the location of MPC.
-
- -

-You need to do one of the following: -

- -
    -
  1. If you have already obtained MPC, either move it underneath the -ACE_wrappers directory or set your MPC_ROOT environment variable to point -to the full path of MPC.
    2. -
  2. Check out MPC from the DOC Group git repository -and set your MPC_ROOT environment variable.
    3. -
- -

-You can check -out MPC from the DOCGroup git repository using the following command. -

- -
git clone https://github.com/DOCGroup/MPC.git MPC
-
- -

-The README and USAGE files in the MPC/docs directory are an up-to-date -source of documentation, however it is not a complete set of -documentation. The TAO Developer's Guide from OCI starting with the -1.3a version contains more information about MPC. -

- -

-The MPC chapter from the TAO Developer's Guide is available at -http://downloads.ociweb.com/MPC/. Some of MPC has changed since -this version, but it is largely accurate. An updated version will be -available as newer versions of the TAO Developer's Guide are released. -In the meantime, please see the README and USAGE files in the MPC -directory. -

- -

-

Working with ACE in Eclipse

- - -

-The Eclipse CDT C++ development environment can be used to develop ACE applications. You can configure a new CDT project to build ACE using either a local source distribution or checking out ACE from CVS in Eclipse. These are the steps to create the CDT project to build ACE. -

- -

-

To create an Eclipse project for ACE starting from CVS:

-
    -
  1. In the "CVS Repository Exploring" perspective, navigate to the module containing ACE.
    2. -
  2. Checkout the module using "Check Out As" and select the "project configured using the New Project Wizard" option.
    3. -
  3. Select "Standard Make C++ Project" for the project type.
    4. -
  4. Follow the steps outlined above, up to the point of running make, for building ACE on your platform. Use "path_to_your_eclipse_workspace"/"project_name" as your $ACE_ROOT. -
  5. If you had to regenerate the makefiles using MPC, select the root folder for your poject and use the import wizard to add them to your project.
    6. -
  6. Select the root folder for the project and use the "Create Make Target" wizard to setup the appropriate make command and options.
    7. -
  7. Select the root folder and run "Build Make Target." This will build ACE.
    8. -
-

- - - -

-

To create an Eclipse project for ACE from a local source distribution:

-
    -
  1. Launch the "New Project Wizard" in Eclipse.
    2. -
  2. Select "Standard Make C++ Project" for the project type.
    3. -
  3. On the project name page, uncheck the "use default" location option and replace the default path with the path to your source distribution.
    4. -
  4. Follow the steps, up to the point of running make, for building ACE on your platform. -
  5. If you had to regenerate the makefiles using MPC, select the root folder for your poject and use the import wizard to add them to your project.
    6. -
  6. Select the root folder for the project and use the "Create Make Target" wizard to setup the appropriate make command and options.
    7. -
  7. Select the root folder and run "Build Make Target." This will build ACE.
    8. - - -
-

- -

- -

-

Advanced Topics

- - - -

-

Non-static -ACE_Object_Manager

The ACE_Object_Manager can be instantiated -as a static object, can be instantiated on the stack of the main -program thread, or can be explicitly instantiated and destroyed by the -application with ACE::init () and ACE::fini -(). The comments in the header file, -ace/Object_Manager.h, as well as Section 1.6.3 in -The ACE Programmer's Guide -provide more detail.

- -NOTE: -Special requirements are imposed on applications if the -ACE_Object_Manager is instantiated, by ACE, on the stack of the main -thread. This behavior is selected by defining -ACE_HAS_NONSTATIC_OBJECT_MANAGER in -ace/config.h. Again, see the ACE Object_Manager header file, -ace/Object_Manager.h for more information. One of -these requirements is discussed here, because it is so important. -Please note that ACE_HAS_NONSTATIC_OBJECT_MANAGER is -defined in the distributed ACE config.h headers for -VxWorks and Win32.

- -The important requirement is that the program must -declare its main function with two arguments, even if -they're not used, and with int return type: - -


-int
-main (int, char *[])
-
- -If you don't declare main exactly that -way, then you'll see a link error about ace_main_i being -undefined.

- -Alternatively, this feature can be disabled by commenting out the -#define ACE_HAS_NONSTATIC_OBJECT_MANAGER in the -ace/config.h. But, that will make repeated testing more -difficult on VxWorks. And, you'd either have to call static -constructors and destructors manually or unload/load the program -between runs. On Win32, disabling the feature can possibly lead to -shutdown difficulties.

- -WARNING: -ACE_HAS_NONSTATIC_OBJECT_MANAGER assumes that your -main function is named main. Any violation -of this assumption is at your peril. If you really need to call your -entry point something other than main, you'll need to -construct and destroy the ACE_Object_Manager. The best way to do that -is to call ACE::init () and ACE::fini (). -Or, see the #define of main (int, char *[]) -in ace/OS_main.h to see how ACE does -that for entry points named main. - -

-

Cloning the Source Tree

- -On UNIX platforms, we typically like to support multiple platform -builds using the same ACE source tree. This idiom is supported by ACE -using the $ACE_ROOT/bin/create_ace_build.pl script. - -To clone the source tree, create ./build and ./build/{your build name} -subdirectories under the ACE_wrappers directory. -Then invoke the create_ace_build.pl script to clone the source tree using -soft links from your build directory back to the actual sources. -Here is an example:

- -

% cd ACE_wrappers
-% mkdir build build/build-SunOS5
-% perl bin/create_ace_build.pl -a -v build-SunOS5
-% cd build/build-SunOS5
-% setenv ACE_ROOT $cwd
-% make
-

- -This will establish a complete tree of links. In addition, make sure -you set your LD_LIBRARY_PATH to -$ACE_ROOT/lib:$LD_LIBRARY_PATH on SVR4 UNIX -platforms.

- -When you do a make in the $ACE_ROOT directory you will be producing -object code that is not stored in the same place as the original -source tree. This way, you can easily build another platform in a -parallel tree structure.

- -See the comments at the top of the create_ace_build.pl script for -further usage information. - -

-

Additional Build Tips for MVS

- -For all intents and purpose, MVS OpenEdition (OE) is another flavor of -UNIX, therefore, the instructions under Building -and Installing ACE on Unix can be used along with the following -additional tips:

- -You can get a copy of GNU make that has been ported to MVS OpenEdition from -the IBM OpenEdition web site. -ACE's make scheme generates compile commands that have options and -operands interspersed. By default, the c89/cc/c++ compiler expects all options to -precede all operands. To get around this, you must set a special -compiler environment variable (_CXX_CCMODE) to 1 which tells the compiler -to allow options and operands to be interspersed.

- -Note that the environment variable LD_LIBRARY_PATH is -called LIBPATH on MVS.

- -Shared objects are built a little different on MVS than on -other UNIX implementations. This has been accounted for in the makefiles -that come with ACE When the linker (via the cxx command) builds the -libACE.so file it will also create a file called libACE.x. This is a -side-deck file and it must be included in subsequent link edits with -application code. For more information on this see the C/C++ MVS -Programming Guide. If you want to build your application statically, -i.e., using libACE.a instead of libACE.so, you can set ACELIB to -ACELIB_STATIC in platform_mvs.GNU.

- -When the libACE.so file is built (via the MVS pre-linker and binder), you -will get a rc=4 from the pre-linker. This is ok. This is due to some -warnings about unresolved references which should get resolved during the -link step. Note, however, there shouldn't be any unresolved references -from the binder (linkage editor). You can get pre-link and link maps by -uncommenting the PMAP and LMAP lines in the platform_mvs.GNU file. - -

-

Makefile Flags

- -GNU make provides many options to customize its operation. See its -documentation for more information. One example is that for multi-cpu -UNIX machines you will be able to build faster if you use:

- -


-% make -j n
-

- -which allows parallel compilation. The number n should -typically be the number of CPUs. It is likely that builds will be -faster even on single-CPU UNIX machines with make -j -2.

- -ACE further supports the following flags. They can be enabled either -on the command line, e.g., "make purify=1", or added to your -platform_macros.GNU. To disable the option, -set the flag to null, -e.g., "make debug=". Some flags support setting to 0 disable, e.g., -"make debug=0". debug=1 is enabled in the platform files that are -released with ACE.

- -Please note that the effects of a flag may be platform specific. -Also, combinations of certain flags may or may not be allowed on -specific platforms, e.g., debug=1 opt=1 is supported by g++ but -not all other C++ compilers.

- -If you use Purify or Quantify: purify or quantify must -be on your PATH. By default, ACE puts the Purify/Quantify -caches below /tmp. To override that, set the -PURE_CACHE_BASE_DIR variable, either in your environment -or on the make make command line, to the destination -directory for your instrumented libraries.

- -

Flag             Description
-----             -----------
-debug            Enable debugging; see DCFLAGS and DCCFLAGS.
-exceptions       Enable exception handling (not supported by all platforms).
-include_env      Support old-style ACE_TRY_ENV declarations in methods.
-                 This switch is necessary for compiling TAO applications
-                 in the native exception configuration that were written
-                 for TAO versions before 1.2.2.
-                 In TAO 1.2.2, new macros were introduced that supercede
-                 the direct ACE_TRY_ENV declarations. These are the
-                 ACE_ENV_ARG macros that are defined in ace/CORBA_macros.h
-                 and are documented in docs/exceptions.html.
-                 This switch only affects the exceptions=1 configuration.
-                 It is for backward compatibility only.
-                 There will be warnings about unused _ACE_environment_variable
-                 parameters when using include_env=1.
-                 If possible, do not use it, but instead change your TAO
-                 applications to use the ACE_ENV_ARG macros.
-fast             Enable -fast option, e.g., with Sun C++.
-inline           Enable ACE inlining.  Some platforms enable inlining by
-                   default, others do not.
-optimize         Enable optimization; see OCFLAGS and OCCFLAGS.
-pace             Enable PACE as the underpinnings of ACE_OS.
-probe            Enable ACE_Timeprobes.
-profile          Enable profiling; see PCFLAGS and PCCFLAGS.
-purify           Purify all executables.
-quantify         Quantify all executables.
-repo             Use GNU template repository (g++ with repo patches only).
-rtti             Enable run-time type identification.  On some platforms,
-                   it is enabled by default, so this is ignored.
-shared_libs      If migrating from prior version use shared_libs_only
-static_libs      If migrating from prior version use static_libs_only
-shared_libs_only Only build shared libraries.  Ignored if no SHLIBs are
-                   specified by the Makefile, as in performance-tests/Misc.
-static_libs_only Only build static libraries.
-threads          Build with thread support.
-xt               Build with Xt (X11 Toolkit) support.
-fl               Build with FlTk (Fast Light Toolkit) support.
-tk               Build with Tk (Tcl/Tk) support.
-qt               Build with Qt (Trolltech Qt) support.
-ssl              Build with OpenSSL support.
-rapi             Build with RAPI
-split            Build the library by first splitting up the ACE source
-                   to several files, with one object code entity for each
-                   source file. This allows an application that is linked
-                   with ACE to extract _exactly_ what it needs from the
-                   library, resulting in a smaller executable.  Setting this
-                   to 1 overrides debug to 0.
-
-Usually, users do not need to be concerned with make targets.
-Just enter "make" on the command line to build.  A few notable
-targets are listed below.
-
-Target             Description
-------             -----------
-show_statics       Lists all static objects in object files built for
-                     current directory.  Only supported for g++.
-show_uninit        Lists all uninitialized in object files built for
-                     current directory.  Only supported for g++.
-
-
- -

- -

Building from git

- -If users are building from our Git repository the -GNUmakefiles, and project files for building on various platforms will -not be available. Git users are expected to generate them -using MPC before building ACE, TAO or -CIAO. We point out some suggestions below to get bootstrapped -quickly. - - - -

-Back to the ACE -home page. -

- - - - - - - -

diff --git a/deps/acelite/ACE.mwc b/deps/acelite/ACE.mwc deleted file mode 100644 index 7899541b3..000000000 --- a/deps/acelite/ACE.mwc +++ /dev/null @@ -1,28 +0,0 @@ -workspace { - exclude { - TAO - } - - // The associate scope does not add directories to the workspace; - // it only associates a name with one or more directories. - associate(examples) { - examples - } - associate(tests) { - performance-tests - tests - } - associate(gperf) { - gperf - } - - // The '--' is a special key that indicates that the associated - // projects should be of the form @NAME@ in the generated Makefile.am. - associate(--) { - ACEXML - ASNMP - protocols - KOKYU - TAO - } -} diff --git a/deps/acelite/AUTHORS b/deps/acelite/AUTHORS deleted file mode 100644 index 98fed3d66..000000000 --- a/deps/acelite/AUTHORS +++ /dev/null @@ -1,13 +0,0 @@ -Douglas C. Schmidt -d.schmidt@vanderbilt.edu - -Professor of Computer Science -Associate Chair of Computer Science and Engineering -Department of Electrical Engineering and Computer Science -Senior Researcher at the Institute for Software Integrated Systems (ISIS) -Vanderbilt University -Nashville, TN 37203 - -www.dre.vanderbilt.edu/~schmidt -TEL: (615) 343-8197 -FAX: (615) 343-7440 diff --git a/deps/acelite/CMakeLists.txt b/deps/acelite/CMakeLists.txt deleted file mode 100644 index 5c94e89fe..000000000 --- a/deps/acelite/CMakeLists.txt +++ /dev/null @@ -1,362 +0,0 @@ -# -# Copyright (C) 2016+ AzerothCore , released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3 -# - -if(NOT CMAKE_SYSTEM_NAME MATCHES "Windows") - add_library(ace SHARED IMPORTED GLOBAL) - - set_target_properties(ace - PROPERTIES - IMPORTED_LOCATION - "${ACE_LIBRARY}" - INTERFACE_INCLUDE_DIRECTORIES - "${ACE_INCLUDE_DIR}") -else() - - # NOTE: Do not use glob here, it would include files we don't want - set(ACE_SOURCES - ace/ACE.cpp - ace/ACE_crc32.cpp - ace/ACE_crc_ccitt.cpp - ace/ATM_Acceptor.cpp - ace/ATM_Addr.cpp - ace/ATM_Connector.cpp - ace/ATM_Params.cpp - ace/ATM_QoS.cpp - ace/ATM_Stream.cpp - ace/Activation_Queue.cpp - ace/Active_Map_Manager.cpp - ace/Addr.cpp - ace/Argv_Type_Converter.cpp - ace/Assert.cpp - ace/Asynch_IO.cpp - ace/Asynch_IO_Impl.cpp - ace/Asynch_Pseudo_Task.cpp - ace/Atomic_Op.cpp - ace/Barrier.cpp - ace/Base_Thread_Adapter.cpp - ace/Based_Pointer_Repository.cpp - ace/Basic_Stats.cpp - ace/Basic_Types.cpp - ace/CDR_Base.cpp - ace/CDR_Size.cpp - ace/CDR_Stream.cpp - ace/Capabilities.cpp - ace/Cleanup.cpp - ace/Codecs.cpp - ace/Codeset_IBM1047.cpp - ace/Codeset_Registry.cpp - ace/Codeset_Registry_db.cpp - ace/Condition_Attributes.cpp - ace/Condition_Recursive_Thread_Mutex.cpp - ace/Condition_Thread_Mutex.cpp - ace/Configuration.cpp - ace/Configuration_Import_Export.cpp - ace/Connection_Recycling_Strategy.cpp - ace/Containers.cpp - ace/Copy_Disabled.cpp - ace/DEV.cpp - ace/DEV_Addr.cpp - ace/DEV_Connector.cpp - ace/DEV_IO.cpp - ace/DLL.cpp - ace/DLL_Manager.cpp - ace/Date_Time.cpp - ace/Dev_Poll_Reactor.cpp - ace/Dirent.cpp - ace/Dirent_Selector.cpp - ace/Dump.cpp - ace/Dynamic.cpp - ace/Dynamic_Message_Strategy.cpp - ace/Dynamic_Service_Base.cpp - ace/Dynamic_Service_Dependency.cpp - ace/Encoding_Converter.cpp - ace/Encoding_Converter_Factory.cpp - ace/Event_Base.cpp - ace/Event_Handler.cpp - ace/Event_Handler_Handle_Timeout_Upcall.cpp - ace/FIFO.cpp - ace/FIFO_Recv.cpp - ace/FIFO_Recv_Msg.cpp - ace/FIFO_Send.cpp - ace/FIFO_Send_Msg.cpp - ace/FILE.cpp - ace/FILE_Addr.cpp - ace/FILE_Connector.cpp - ace/FILE_IO.cpp - ace/File_Lock.cpp - ace/Filecache.cpp - ace/Flag_Manip.cpp - ace/Framework_Component.cpp - ace/Functor.cpp - ace/Functor_String.cpp - ace/Get_Opt.cpp - ace/Handle_Ops.cpp - ace/Handle_Set.cpp - ace/Hashable.cpp - ace/High_Res_Timer.cpp - ace/ICMP_Socket.cpp - ace/INET_Addr.cpp - ace/IOStream.cpp - ace/IO_Cntl_Msg.cpp - ace/IO_SAP.cpp - ace/IPC_SAP.cpp - ace/Init_ACE.cpp - ace/LSOCK.cpp - ace/LSOCK_Acceptor.cpp - ace/LSOCK_CODgram.cpp - ace/LSOCK_Connector.cpp - ace/LSOCK_Dgram.cpp - ace/LSOCK_Stream.cpp - ace/Lib_Find.cpp - ace/Local_Memory_Pool.cpp - ace/Local_Name_Space.cpp - ace/Local_Tokens.cpp - ace/Lock.cpp - ace/Log_Category.cpp - ace/Log_Msg.cpp - ace/Log_Msg_Android_Logcat.cpp - ace/Log_Msg_Backend.cpp - ace/Log_Msg_Callback.cpp - ace/Log_Msg_IPC.cpp - ace/Log_Msg_NT_Event_Log.cpp - ace/Log_Msg_UNIX_Syslog.cpp - ace/Log_Record.cpp - ace/Logging_Strategy.cpp - ace/MEM_Acceptor.cpp - ace/MEM_Addr.cpp - ace/MEM_Connector.cpp - ace/MEM_IO.cpp - ace/MEM_SAP.cpp - ace/MEM_Stream.cpp - ace/MMAP_Memory_Pool.cpp - ace/Malloc.cpp - ace/Malloc_Allocator.cpp - ace/Mem_Map.cpp - ace/Message_Block.cpp - ace/Message_Queue.cpp - ace/Message_Queue_NT.cpp - ace/Message_Queue_Vx.cpp - ace/Method_Request.cpp - ace/Monitor_Admin.cpp - ace/Monitor_Admin_Manager.cpp - ace/Monitor_Base.cpp - ace/Monitor_Control_Action.cpp - ace/Monitor_Control_Types.cpp - ace/Monitor_Point_Registry.cpp - ace/Monitor_Size.cpp - ace/Monotonic_Time_Policy.cpp - ace/Msg_WFMO_Reactor.cpp - ace/Multihomed_INET_Addr.cpp - ace/Mutex.cpp - ace/NT_Service.cpp - ace/Name_Proxy.cpp - ace/Name_Request_Reply.cpp - ace/Name_Space.cpp - ace/Naming_Context.cpp - ace/Netlink_Addr.cpp - ace/Notification_Queue.cpp - ace/Notification_Strategy.cpp - ace/Null_Mutex.cpp - ace/OS_Errno.cpp - ace/OS_Log_Msg_Attributes.cpp - ace/OS_NS_Thread.cpp - ace/OS_NS_arpa_inet.cpp - ace/OS_NS_ctype.cpp - ace/OS_NS_devctl.cpp - ace/OS_NS_dirent.cpp - ace/OS_NS_dlfcn.cpp - ace/OS_NS_errno.cpp - ace/OS_NS_fcntl.cpp - ace/OS_NS_math.cpp - ace/OS_NS_netdb.cpp - ace/OS_NS_poll.cpp - ace/OS_NS_pwd.cpp - ace/OS_NS_regex.cpp - ace/OS_NS_signal.cpp - ace/OS_NS_stdio.cpp - ace/OS_NS_stdlib.cpp - ace/OS_NS_string.cpp - ace/OS_NS_strings.cpp - ace/OS_NS_stropts.cpp - ace/OS_NS_sys_mman.cpp - ace/OS_NS_sys_msg.cpp - ace/OS_NS_sys_resource.cpp - ace/OS_NS_sys_select.cpp - ace/OS_NS_sys_sendfile.cpp - ace/OS_NS_sys_shm.cpp - ace/OS_NS_sys_socket.cpp - ace/OS_NS_sys_stat.cpp - ace/OS_NS_sys_time.cpp - ace/OS_NS_sys_uio.cpp - ace/OS_NS_sys_utsname.cpp - ace/OS_NS_sys_wait.cpp - ace/OS_NS_time.cpp - ace/OS_NS_unistd.cpp - ace/OS_NS_wchar.cpp - ace/OS_NS_wctype.cpp - ace/OS_QoS.cpp - ace/OS_TLI.cpp - ace/OS_Thread_Adapter.cpp - ace/OS_main.cpp - ace/Obchunk.cpp - ace/Object_Manager.cpp - ace/Object_Manager_Base.cpp - ace/Obstack.cpp - ace/PI_Malloc.cpp - ace/POSIX_Asynch_IO.cpp - ace/POSIX_CB_Proactor.cpp - ace/POSIX_Proactor.cpp - ace/Pagefile_Memory_Pool.cpp - ace/Parse_Node.cpp - ace/Ping_Socket.cpp - ace/Pipe.cpp - ace/Priority_Reactor.cpp - ace/Proactor.cpp - ace/Proactor_Impl.cpp - ace/Process.cpp - ace/Process_Manager.cpp - ace/Process_Mutex.cpp - ace/Process_Semaphore.cpp - ace/Profile_Timer.cpp - ace/RW_Mutex.cpp - ace/RW_Process_Mutex.cpp - ace/RW_Thread_Mutex.cpp - ace/Reactor.cpp - ace/Reactor_Impl.cpp - ace/Reactor_Notification_Strategy.cpp - ace/Reactor_Timer_Interface.cpp - ace/Read_Buffer.cpp - ace/Recursive_Thread_Mutex.cpp - ace/Recyclable.cpp - ace/Registry.cpp - ace/Registry_Name_Space.cpp - ace/Remote_Name_Space.cpp - ace/Remote_Tokens.cpp - ace/SOCK.cpp - ace/SOCK_Acceptor.cpp - ace/SOCK_CODgram.cpp - ace/SOCK_Connector.cpp - ace/SOCK_Dgram.cpp - ace/SOCK_Dgram_Bcast.cpp - ace/SOCK_Dgram_Mcast.cpp - ace/SOCK_IO.cpp - ace/SOCK_Netlink.cpp - ace/SOCK_SEQPACK_Acceptor.cpp - ace/SOCK_SEQPACK_Association.cpp - ace/SOCK_SEQPACK_Connector.cpp - ace/SOCK_Stream.cpp - ace/SPIPE.cpp - ace/SPIPE_Acceptor.cpp - ace/SPIPE_Addr.cpp - ace/SPIPE_Connector.cpp - ace/SPIPE_Stream.cpp - ace/SString.cpp - ace/SUN_Proactor.cpp - ace/SV_Message.cpp - ace/SV_Message_Queue.cpp - ace/SV_Semaphore_Complex.cpp - ace/SV_Semaphore_Simple.cpp - ace/SV_Shared_Memory.cpp - ace/Sample_History.cpp - ace/Sbrk_Memory_Pool.cpp - ace/Sched_Params.cpp - ace/Select_Reactor_Base.cpp - ace/Semaphore.cpp - ace/Service_Config.cpp - ace/Service_Gestalt.cpp - ace/Service_Manager.cpp - ace/Service_Object.cpp - ace/Service_Repository.cpp - ace/Service_Types.cpp - ace/Shared_Memory.cpp - ace/Shared_Memory_MM.cpp - ace/Shared_Memory_Pool.cpp - ace/Shared_Memory_SV.cpp - ace/Shared_Object.cpp - ace/Sig_Adapter.cpp - ace/Sig_Handler.cpp - ace/Signal.cpp - ace/Sock_Connect.cpp - ace/Stack_Trace.cpp - ace/Stats.cpp - ace/String_Base_Const.cpp - ace/Svc_Conf_Lexer.cpp - ace/Svc_Conf_y.cpp - ace/Synch_Options.cpp - ace/System_Time.cpp - ace/TLI.cpp - ace/TLI_Acceptor.cpp - ace/TLI_Connector.cpp - ace/TLI_Stream.cpp - ace/TP_Reactor.cpp - ace/TSS_Adapter.cpp - ace/TTY_IO.cpp - ace/Task.cpp - ace/Thread.cpp - ace/Thread_Adapter.cpp - ace/Thread_Control.cpp - ace/Thread_Exit.cpp - ace/Thread_Hook.cpp - ace/Thread_Manager.cpp - ace/Thread_Mutex.cpp - ace/Thread_Semaphore.cpp - ace/Throughput_Stats.cpp - ace/Time_Policy.cpp - ace/Time_Value.cpp - ace/Timeprobe.cpp - ace/Token.cpp - ace/Token_Collection.cpp - ace/Token_Invariants.cpp - ace/Token_Manager.cpp - ace/Token_Request_Reply.cpp - ace/Trace.cpp - ace/UNIX_Addr.cpp - ace/UPIPE_Acceptor.cpp - ace/UPIPE_Connector.cpp - ace/UPIPE_Stream.cpp - ace/UTF16_Encoding_Converter.cpp - ace/UTF32_Encoding_Converter.cpp - ace/UTF8_Encoding_Converter.cpp - ace/UUID.cpp - ace/WFMO_Reactor.cpp - ace/WIN32_Asynch_IO.cpp - ace/WIN32_Proactor.cpp - ace/XML_Svc_Conf.cpp - ace/XTI_ATM_Mcast.cpp - ace/ace_wchar.cpp) - - if (USE_COREPCH) - set(PRIVATE_PCH_HEADER ace/PrecompiledHeaders/WinAcePCH.h) - endif() - - # Group sources - GroupSources(${CMAKE_CURRENT_SOURCE_DIR}) - - add_library(ace STATIC - ${ACE_SOURCES}) - - target_include_directories(ace - PUBLIC - ${CMAKE_CURRENT_SOURCE_DIR}) - - target_compile_definitions(ace - PUBLIC - ACE_AS_STATIC_LIBS - $<$:_WANT_SEMUN>) - - target_link_libraries(ace - PRIVATE - acore-dependency-interface Iphlpapi) - - set_target_properties(ace - PROPERTIES - FOLDER - "deps") - - # Generate precompiled header - if(USE_COREPCH) - add_cxx_pch(ace ${PRIVATE_PCH_HEADER}) - endif() - -endif() diff --git a/deps/acelite/COPYING b/deps/acelite/COPYING deleted file mode 100644 index 5917f76aa..000000000 --- a/deps/acelite/COPYING +++ /dev/null @@ -1,111 +0,0 @@ - - _________________________________________________________________ - - Copyright and Licensing Information for ACE(TM), TAO(TM), CIAO(TM), - DAnCE(TM), and CoSMIC(TM) - - [1]ACE(TM), [2]TAO(TM), [3]CIAO(TM), DAnCE(TM), and [4]CoSMIC(TM) - (henceforth referred to as "DOC software") are copyrighted by - [5]Douglas C. Schmidt and his [6]research group at [7]Washington - University, [8]University of California, Irvine, and [9]Vanderbilt - University, Copyright (c) 1993-2019, all rights reserved. Since DOC - software is open-source, freely available software, you are free to - use, modify, copy, and distribute--perpetually and irrevocably--the - DOC software source code and object code produced from the source, as - well as copy and distribute modified versions of this software. You - must, however, include this copyright statement along with any code - built using DOC software that you release. No copyright statement - needs to be provided if you just ship binary executables of your - software products. - - You can use DOC software in commercial and/or binary software releases - and are under no obligation to redistribute any of your source code - that is built using DOC software. Note, however, that you may not - misappropriate the DOC software code, such as copyrighting it yourself - or claiming authorship of the DOC software code, in a way that will - prevent DOC software from being distributed freely using an - open-source development model. You needn't inform anyone that you're - using DOC software in your software, though we encourage you to let - [10]us know so we can promote your project in the [11]DOC software - success stories. - - The [12]ACE, [13]TAO, [14]CIAO, [15]DAnCE, and [16]CoSMIC web sites - are maintained by the [17]DOC Group at the [18]Institute for Software - Integrated Systems (ISIS) and the [19]Center for Distributed Object - Computing of Washington University, St. Louis for the development of - open-source software as part of the open-source software community. - Submissions are provided by the submitter ``as is'' with no warranties - whatsoever, including any warranty of merchantability, noninfringement - of third party intellectual property, or fitness for any particular - purpose. In no event shall the submitter be liable for any direct, - indirect, special, exemplary, punitive, or consequential damages, - including without limitation, lost profits, even if advised of the - possibility of such damages. Likewise, DOC software is provided as is - with no warranties of any kind, including the warranties of design, - merchantability, and fitness for a particular purpose, - noninfringement, or arising from a course of dealing, usage or trade - practice. Washington University, UC Irvine, Vanderbilt University, - their employees, and students shall have no liability with respect to - the infringement of copyrights, trade secrets or any patents by DOC - software or any part thereof. Moreover, in no event will Washington - University, UC Irvine, or Vanderbilt University, their employees, or - students be liable for any lost revenue or profits or other special, - indirect and consequential damages. - - DOC software is provided with no support and without any obligation on - the part of Washington University, UC Irvine, Vanderbilt University, - their employees, or students to assist in its use, correction, - modification, or enhancement. A [20]number of companies around the - world provide commercial support for DOC software, however. DOC - software is Y2K-compliant, as long as the underlying OS platform is - Y2K-compliant. Likewise, DOC software is compliant with the new US - daylight savings rule passed by Congress as "The Energy Policy Act of - 2005," which established new daylight savings times (DST) rules for - the United States that expand DST as of March 2007. Since DOC software - obtains time/date and calendaring information from operating systems - users will not be affected by the new DST rules as long as they - upgrade their operating systems accordingly. - - The names ACE(TM), TAO(TM), CIAO(TM), DAnCE(TM), CoSMIC(TM), - Washington University, UC Irvine, and Vanderbilt University, may not - be used to endorse or promote products or services derived from this - source without express written permission from Washington University, - UC Irvine, or Vanderbilt University. This license grants no permission - to call products or services derived from this source ACE(TM), - TAO(TM), CIAO(TM), DAnCE(TM), or CoSMIC(TM), nor does it grant - permission for the name Washington University, UC Irvine, or - Vanderbilt University to appear in their names. - - If you have any suggestions, additions, comments, or questions, please - let [21]me know. - - [22]Douglas C. Schmidt - _________________________________________________________________ - - Back to the [23]ACE home page. - -References - - 1. https://www.dre.vanderbilt.edu/~schmidt/ACE.html - 2. https://www.dre.vanderbilt.edu/~schmidt/TAO.html - 3. https://www.dre.vanderbilt.edu/CIAO/ - 4. https://www.dre.vanderbilt.edu/cosmic/ - 5. https://www.dre.vanderbilt.edu/~schmidt/ - 6. https://www.dre.vanderbilt.edu/~schmidt/ACE-members.html - 7. https://www.wustl.edu/ - 8. https://www.uci.edu/ - 9. https://www.vanderbilt.edu/ - 10. mailto:d.schmidt@vanderbilt.edu - 11. https://www.dre.vanderbilt.edu/~schmidt/ACE-users.html - 12. https://www.dre.vanderbilt.edu/~schmidt/ACE.html - 13. https://www.dre.vanderbilt.edu/~schmidt/TAO.html - 14. https://www.dre.vanderbilt.edu/CIAO/ - 15. https://www.dre.vanderbilt.edu/~schmidt/DOC_ROOT/DAnCE/ - 16. https://www.dre.vanderbilt.edu/cosmic/ - 17. https://www.dre.vanderbilt.edu/ - 18. https://www.isis.vanderbilt.edu/ - 19. https://www.cs.wustl.edu/~schmidt/doc-center.html - 20. https://www.dre.vanderbilt.edu/~schmidt/commercial-support.html - 21. mailto:d.schmidt@vanderbilt.edu - 22. https://www.dre.vanderbilt.edu/~schmidt/ - 23. https://www.dre.vanderbilt.edu/~schmidt/ACE.html diff --git a/deps/acelite/NEWS b/deps/acelite/NEWS deleted file mode 100644 index 1f2586f1c..000000000 --- a/deps/acelite/NEWS +++ /dev/null @@ -1,2395 +0,0 @@ -USER VISIBLE CHANGES BETWEEN ACE-6.5.9 and ACE-6.5.10 -===================================================== - -. Add support for Embarcadero C++ Builder 10.4 Sydney using the - classic compiler. ACE/TAO compile with the new 32/64 bit clang - compilers but runtime tests show several runtime problems which - makes them not safe to use - -. Make a change in the ACE Process Manager to resolve an internal - compiler error with Visual Studio 2019 16.5.x compilers - -. Android enhancements for if_nameindex - -USER VISIBLE CHANGES BETWEEN ACE-6.5.8 and ACE-6.5.9 -==================================================== - -. On Windows, ACE no longer defines _WIN32_WINNT. ACE wrappers for - if_nametoindex and if_indextoname are available if the version of the - Windows SDK supports them. - -. IPv6 extended datagram receive info now supported on macOS. - -. ACE_(U)INT8/16/32/64 map to (u)int8/16/32/64_t when C++11 has been - enabled. - -. CDR_Base uses ACE_INT64 for LongLong, all old emulated support - has been removed - -. Updated debian and rpm packaging support - -USER VISIBLE CHANGES BETWEEN ACE-6.5.7 and ACE-6.5.8 -==================================================== - -. Added instructions to ACE-INSTALL.html for building ACE/TAO for Android on - Windows. - -. Embarcadero C++ Builder Rio fixes - -. Renamed `VERSION` file to `VERSION.txt` to avoid conflicting with the - `version` standard header. - -USER VISIBLE CHANGES BETWEEN ACE-6.5.6 and ACE-6.5.7 -==================================================== - -. Fixed compile problem with glibc 2.30 and newer - -. gnuace makefiles: Updated handling of generated files and - use requires/avoids to make postbuild steps conditional - -. Removed references to the ACE_LACKS_MONOTONIC_TIME preprocessor macro because - it was equivalent to ACE_LACKS_CLOCK_MONOTONIC. - -. Exposed support status of monotonic times features using preprocessor macros. - See "Testing for Monotonic Time Support" in docs/ACE-monotonic-timer.html for - details. - -. Added support for ARM and ARM64 stack traces with Microsoft Visual C++. - -. The "optional argument for the receive address in ACE_SOCK_Dgram::recv" - feature from ACE-6.5.5 is now supported on Windows. This includes enhanced - support for sendmsg/recvmsg on Windows. - -USER VISIBLE CHANGES BETWEEN ACE-6.5.5 and ACE-6.5.6 -==================================================== - -. On Linux, the ACE_Log_Msg format specifier `%t` is now replaced with the - system thread id provided by gettid(), instead of the much longer pthread id. - -. Added support for MQX - -. Enhanced Android support - -USER VISIBLE CHANGES BETWEEN ACE-6.5.4 and ACE-6.5.5 -==================================================== - -. Fixed several broken links due to the removal of - Douglas Schmidt website at WashU - -. On Android: - - . ACE_Log_Msg (and therefore ACE_DEBUG and ACE_ERROR) now uses - Android's logging system (aka Logcat) by default in addition to stderr - because stdout and stderr are discarded under normal circumstances. - To disable this at runtime, run: - ACE_LOG_MSG->clr_flags (ACE_Log_Msg::SYSLOG) - To disable this at compile time include these lines in config.h: - #define ACE_DEFAULT_LOG_FLAGS ACE_Log_Msg::STDERR - #define ACE_DEFAULT_LOG_BACKEND_FLAGS 0 - - . When statically linking to OpenSSL, prevent usage of the preloaded and - unpredictable system SSL library when using ace_openssl. - -. minizip has been moved from ACE to DANCE - -. Add initial support for Visual Studio 2019 - -. Validated ACE for usage SLES15.0 x86_64 using 32bit g++ compiler - -. Add optional argument for the receive address in ACE_SOCK_Dgram::recv - -USER VISIBLE CHANGES BETWEEN ACE-6.5.3 and ACE-6.5.4 -==================================================== - -. Fix ACE_Vector::end(), which now correctly - represents the end of the elements of the vector - instead of the end of the base array. - -USER VISIBLE CHANGES BETWEEN ACE-6.5.2 and ACE-6.5.3 -==================================================== - -. Enhance Android support - -. Fix AIX and Solaris linking rpath errors - -. Add support for SSL_INCDIR/SSL_LIBDIR and XERCESC_INCDIR/XERCESC_LIBDIR - to specify a custom include/lib dir as required for vcpkg versions of - openssl/xercesc - -USER VISIBLE CHANGES BETWEEN ACE-6.5.1 and ACE-6.5.2 -==================================================== - -. Enhanced C++Builder XE2 support - -. ACE_QtReactor can be built with Qt version 5 using the qt5 MPC feature - -USER VISIBLE CHANGES BETWEEN ACE-6.5.0 and ACE-6.5.1 -==================================================== - -. At the moment C++11 or newer is enabled ACE_Strong_Bound_Ptr - doesn't provide the convenience functions to use a - std::auto_ptr anymore - -. Optimized CDR std::(w)string insertion and extraction - when C++11 or newer is enabled - -. Solved Visual Studio 2017 solution loading due to duplicate - files generated in a project file - -USER VISIBLE CHANGES BETWEEN ACE-6.4.8 and ACE-6.5.0 -==================================================== - -. The ACE core libraries now use std::unique_ptr instead - of std::auto_ptr when C++11 or newer is enabled - -USER VISIBLE CHANGES BETWEEN ACE-6.4.7 and ACE-6.4.8 -==================================================== - -. Enhanced Embarcadero C++ Builder support - -. ACE XML_Utils enhancements - -. Debian packaging enhancements - -. Support for clang6 and gcc8 - -. Enhanced Android support - -. Remove addr_any restriction from ipv6_only UDP - -USER VISIBLE CHANGES BETWEEN ACE-6.4.6 and ACE-6.4.7 -==================================================== - -. Added a new, optional argument named ipv6_only to: - ACE_Acceptor::ACE_Acceptor - ACE_Acceptor::open - ACE_SOCK_Dgram::ACE_SOCK_Dgram - ACE_SOCK_Dgram::open - If ipv6_only is 0/false (the default) the socket will accept - both IPv6 and IPv4 connections/datagrams. If ipv6_only is - 1/true the socket will only accept IPv6. - This behavior only applies when ACE_HAS_IPV6 is true and the - local-side IP address is the generic localhost IP address. - -. Integrated some changes from XSC into XML Utils - -. Enable ACE_HAS_CPP11 when we have clang with C++11 enabled - -. Added support for cross compiling using MinGW on a Linux host - -. Added support for FreeBSD 11 - -. Fixed issue ACE_Singleton was broken after ACE::fini, ACE::init (GitHub #554) - -USER VISIBLE CHANGES BETWEEN ACE-6.4.5 and ACE-6.4.6 -==================================================== - -. Fixed some Codacy and C++ Core guidelines reported issues - -. VxWorks 7 (SR0510) support - -. Support make install on newer Apple MacOS versions - -USER VISIBLE CHANGES BETWEEN ACE-6.4.4 and ACE-6.4.5 -==================================================== - -. Add support for OpenSSL 1.1. ACE users on Windows have - to add openssl11=1 to their default.features file so - that the correct OpenSSL library names are used. - -USER VISIBLE CHANGES BETWEEN ACE-6.4.3 and ACE-6.4.4 -==================================================== - -. Enhanced support for Embarcadero C++ Builder 10.2 (Tokyo). - Support for bcc32/bcc64/bcc32c has been enhanced and by - default the clang based versions are used. When the old - bcc32 has to be used set the CLASSIC environment variable - to 1. At this moment runtime test results for bcc64/bcc32c - show some structural problems - -. Add support for Oracle Studio 12.5 - -. Removed usage of ACE_REGISTER and register keyword because - they trigger deprecated warnings with newer gcc and clang - versions - -. Add support for gcc 7 - -. Enhanced Android support - -. Fix ACE_INET_Addr::set(domain_name, AF_UNSPEC) to be set to IPv4 address - when IPv6 is enabled and the domain_name could be resolved to IPv4 address. - -USER VISIBLE CHANGES BETWEEN ACE-6.4.2 and ACE-6.4.3 -==================================================== - -. Enhancements for Visual Studio 2017 - -. Enhancements for Android - -USER VISIBLE CHANGES BETWEEN ACE-6.4.1 and ACE-6.4.2 -==================================================== - -. Added support for Mac OS X on x86_64 to get the network adapter - address in ACE_OS::getmacaddress(). - -. Added support for the December 2016 updates to VxWorks 7. - -USER VISIBLE CHANGES BETWEEN ACE-6.4.0 and ACE-6.4.1 -==================================================== - -. The ACE_DEBUG environment variable can again be used to set the - internal debug flag. This used to work but was mistakenly changed - in an earlier release. - -. Corrected usage of ACE_Singleton and template instantation to be - valid C++ (GCC cross-compiler arm-linux-gnueabihf-g++ requires it). - -. Added support for detecting the Mac OS X version when configured with - ace/config-macosx.h and include/makeinclude/platform_macosx.GNU. - Also on 10.11 El Capitan, use rpath to avoid a problem with SIP. - -. Added support for Android NDK r12b (Platform API 24) and improved - cross compilation support - -USER VISIBLE CHANGES BETWEEN ACE-6.3.4 and ACE-6.4.0 -==================================================== - -. Added support for obtaining the micro version number - -. Reduced include of ace/Auto_Ptr.h in header files - -USER VISIBLE CHANGES BETWEEN ACE-6.3.3 and ACE-6.3.4 -==================================================== - -. ACE_SSL_Context::set_mode() can no longer be used to select a specific - SSL/TLS protocol version, use ACE_SSL_Context::filter_versions() for that. - This follows general advice by the OpenSSL project to go through - SSL_CTX_set_options() to limit the list of protocols available. The purpose - of ACE_SSL_Context::set_mode() is now limited to explicitly restricting - behaviour to client or server (defaults to both). - -. Improve Oracle Studio support - -. CIAO and DAnCE are forked to their own github repositories - and are not part anymore of the ACE+TAO release packages - -. Fixed several Coverity reported issues - -. Added ACE configuration for FACE safety profiles (see config-face-safety.h). - FACE, or Future Airborne Capability Environment http://www.opengroup.org/face, - specifies a restricted subset of OS functions and rules for controlling - dynamic memory allocation. When built in this configuration on a platform - that supports it, ACE conforms to the FACE requirements. - -. ACE uses new netdb.h functions (getaddrinfo/getnameinfo) if they are - available, in place of deprecated functions (gethostbyname/addr). - -USER VISIBLE CHANGES BETWEEN ACE-6.3.2 and ACE-6.3.3 -==================================================== - -. Visual Studio 2015 has adequate C++11 support, because of this - ACE_HAS_CPP11 is now defined with this compiler. A large amount - of warnings given by this new compiler have been fixed - -. As part of the release script we generate vc12 and vc14 - solution files which are packaged as part of the release - -. Added support for VxWorks 7 (kernel mode and RTP). - See the comments in include/makeinclude/platform_vxworks7.0.GNU for details. - -. Ended daily maintenance for OpenVMS - -. Fixed a defect in ACE_INET_Addr when there is a non-empty interface - address list and set_port_number() is called. - -USER VISIBLE CHANGES BETWEEN ACE-6.3.1 and ACE-6.3.2 -==================================================== - -. Added support for std::chrono to ACE_Time_Value. It's - now possible to construct an ACE_Time_Value with a - std::duration. Also streaming, adding and substracting - an ACE_Time_Value to and from a std::duration is - supported. Please see tests/Chrono_Test.cpp for more - details. - -. Allow ACE_INET_Addr to hold all addresses associated with a hostname. The - set of addresses always has a "current" address which is accessed by the - usual "get"-type methods on the class. Two new methods are added to deal - with multiple addresses: - - bool next (void): makes the next available address the "current" one. - Returns false if there are no more addresses. - - void reset (void): resets the iteration mechanism to be able to examine - all of the addresses again. - ACE_Multihomed_INET_Addr has also been enhanced so that the get_addresses() - methods copy all available addresses related to each name. - -. The ACE_Addr::set_addr (void*, int) signature was changed to - ACE_Addr::set_addr (const void*, int). All classes that inherit from - ACE_Addr also have the same change. This affects ACE_ATM_Addr, ACE_Addr, - ACE_INET_Addr, ACE_MEM_Addr, ACE_Netlink_Addr, ACE_SPIPE_Addr, ACE_UNIX_Addr. - Any user-written classes derived from ACE_Addr will also need to change to - match the new signature for virtual method dispatch to continue working - properly in all cases. - -. Added the class ACE_CDR::Fixed (CDR_Base.h) for CDR's fixed-point decimal - data type which stores up to 31 decimal digits and a sign bit. - -USER VISIBLE CHANGES BETWEEN ACE-6.3.0 and ACE-6.3.1 -==================================================== - -. ACE is now hosted on github (https://github.com/DOCGroup/ATCD). - As part of the release process we now generate a ChangeLog - for each release which is stored in the ChangeLogs directory - -. ACE has been ported to OpenBSD 5.6. Old versions of - OpenBSD are no longer supported. - -USER VISIBLE CHANGES BETWEEN ACE-6.2.8 and ACE-6.3.0 -==================================================== - -. ACE now supports Oracle Solaris Studio 12.4 on Solaris. - -. New config macros were added: - ACE_DISABLE_MKTEMP: Disables the availability of ACE_OS::mktemp(). - ACE_DISABLE_TEMPNAM: Disables the availability of ACE_OS::tempnam(). - These can be added to your $ACE_ROOT/ace/config.h to disable these - wrappers which are considered to be a potential security risk. Disabling - one or both will also disable the following: - - ACE_FILE_Addr::set () with the 'any' address specified. - - ACE_MMAP_Memory_Pool use of the 'unique' option. - -. Reduced size of all doxygen documentation by changing the - type of diagrams shown - -. Removed Windows specific workarounds from ACE_OS::setsockopt, as a - result SO_REUSEPORT is not defined anymore on Windows and SO_REUSEADDR - is passed directly to the OS - -. By adding a 'specific' section to a MPC (base) project it is now possible - to have object file output directories per project for GNUACE projects. - The following should be added to MPC projects (bugzilla #3868): - specific(gnuace) { - build_dir_per_project=1 - } - -. ACE_Asynch_Write_File will now correctly accept non-socket (file, TTY ..) - handles (bugzilla #3762 and #3992) - -. Fixes for VxWorks 6.9 - -USER VISIBLE CHANGES BETWEEN ACE-6.2.7 and ACE-6.2.8 -==================================================== - -. Add new ACE::make_event_handler() which is similar - to std::make_shared but than for allocation of ACE - event handlers. This template method is only enabled - when ACE_HAS_CPP11 has been defined, which is set - automatically when a C++ compiler with adequate - C++11 support is used. Also ACE_Event_Handler_var is - extended with some C++11 specific operations - -. For all reactor types calling cancel_timer with a - nullptr is now allowed, will result in a return of 0 - -. ACE_DLL and ACE_DLL_Manager have been extended with - the support to retrieve any dynamic loader errors - -USER VISIBLE CHANGES BETWEEN ACE-6.2.6 and ACE-6.2.7 -==================================================== - -. Added configuration files for Microsoft Visual Studio 2014 - -. Added configuration files for MacOSX Yosemite - -. Added configuration files for IBM AIX XL C++ 12.1 - -USER VISIBLE CHANGES BETWEEN ACE-6.2.5 and ACE-6.2.6 -==================================================== - -. Resolved several data races reported by Intel Inspector XE - -. Added optional socket connection optimization for Windows - -. Improve functionality and stability of running tests on - Android Virtual Device (AVD). - -USER VISIBLE CHANGES BETWEEN ACE-6.2.4 and ACE-6.2.5 -==================================================== - -. Added the ability to build RPMs for just ACE, using an ACE-src tarball. - To do this add "--without tao" to the rpmbuild command line. - -. Added support for Embarcadero C++Builder XE5 using - bcc32 in debug and release mode - -. Added support for Embarcadero C++Builder XE6 using - bcc32 in debug and release mode - -. When Intel C++ 2013 SP1 Update 2 is used with C++11 enabled - as compiler feature now also ACE_HAS_CPP11 will be defined, - this compiler is now able to compile all our C++11 feature - tests - -. Fixed several boundary bugs in the ACE RLE Compressor - -USER VISIBLE CHANGES BETWEEN ACE-6.2.3 and ACE-6.2.4 -==================================================== - -. Added support for FC20 and ended maintenance for FC19 - -. Extended C++11 feature test suite - -. Improved support for MingW64 - -. Improvements to IPv6 support on Windows - -USER VISIBLE CHANGES BETWEEN ACE-6.2.2 and ACE-6.2.3 -==================================================== - -. The ACE_OS::thr_join() method will detect if the thread to be waited on is - the calling thread and avert that deadlock. The support needed for this - method is available at Vista/Windows Server 2003 and higher; to enable - the deadlock prevention, compile ACE with _WIN32_WINNT=0x0502 or higher. - -. Ended maintenance and support for FC12 CEEL - -. Further improvements of the Android port: Added new define - ACE_HAS_EXPLICIT_TEMPLATE_CLASS_INSTANTIATION and related macros - ACE_SINGLETON_TEMPLATE_INSTANTIATION and ACE_SINGLETON_TEMPLATE_INSTANTIATE - providing a cleaner way to support explicit template (static member or class) - instantiation. - -' Improvements of the test framework for running tests in a mixed environment - where different targets run on different physiscal devices (possibly having - different OS). - -USER VISIBLE CHANGES BETWEEN ACE-6.2.1 and ACE-6.2.2 -==================================================== - -. The max_len argument to ACE_Process::command_line_buf changed from int* - to size_t*. This corrects a mismatch between the argument type and the - data member in ACE_Process from which the value comes. - -. Removed some include files from ACE.h. These were not required for ACE. - The removed includes are OS_NS_math, Flag_Manip, Handle_Ops, Lib_Find, - Init_ACE, Sock_Connect.h. You may have to explicitly add one of these - in your own code to restore compiling. - -. Further improvements of the Android port, still work in progress. - -USER VISIBLE CHANGES BETWEEN ACE-6.2.0 and ACE-6.2.1 -==================================================== - -. Added support for Fedora 19, ended daily maintenance - for Fedora 17 and 18 - -. Added support for Embarcadero C++BuilderXE4 using - bcc32 in debug and release mode - -. Improved support for Android - -USER VISIBLE CHANGES BETWEEN ACE-6.1.9 and ACE-6.2.0 -==================================================== - -. None - -USER VISIBLE CHANGES BETWEEN ACE-6.1.8 and ACE-6.1.9 -==================================================== - -. Added MinGW64 as supported platform - -. Added support for GCC 4.8.0 - -USER VISIBLE CHANGES BETWEEN ACE-6.1.7 and ACE-6.1.8 -==================================================== - -. Small bug fixes - -USER VISIBLE CHANGES BETWEEN ACE-6.1.6 and ACE-6.1.7 -==================================================== - -. Integrated several patches to simplify Debian/Ubuntu - packaging - -USER VISIBLE CHANGES BETWEEN ACE-6.1.5 and ACE-6.1.6 -==================================================== - -. Added new event and sema initialization methods to OS_NS_Thread - to allow passing pre-initialized condition attributes providing - basic support for using time policies in ACE Event classes. - -. Added TIME_POLICY support to ACE_Event classes to allow for - monotonic timer support for ACE Events. - -. Added new regression test: - Monotonic_Manual_Event_Test - -USER VISIBLE CHANGES BETWEEN ACE-6.1.4 and ACE-6.1.5 -==================================================== - -. When a ACE_Event_Handler registered for signals is unregistered, - whether by unregistering, returning -1 from handle_signal(), or by - the reactor closing, the ACE_Event_Handler::handle_close() hook will - be called. The close_mask passed will be ACE_Event_Handler::SIGNAL_MASK. - In previous versions, handle_close() would only be called when the - handle_signal() callback returned -1. This resolves Bugzilla #2368. - -. Some initial ACE unit tests to validate the C++11 support of various - compilers - -. Added support for OpenSuSE 12.2 - -USER VISIBLE CHANGES BETWEEN ACE-6.1.3 and ACE-6.1.4 -==================================================== - -. Added a new ACE_Time_Value derived template class (Time_Value_T.h): - - template class ACE_Time_Value_T - - This template class overloads 4 new virtual methods from - the ACE_Time_Value base class to provide time policy aware - time values: - to_relative_time () - to_absolute_time () - now () - duplicate () - -. Updated time policy classes to return ACE_Time_Value_T<> instantiations - for the corresponding time policy instead of 'common' time values. - -. Added new ACE_Monotonic_Time_Policy (Monotonic_Time_Policy.h). - This class provides a monotonic time source for supported - platforms (Windows and POSIX platforms providing the required - clock_gettime() time source; currently verified for Windows and - Linux) - -. Updated OS_NS_Thread to use the new time policy support in ACE_Time_Value - for (relative) time calculations and added new ACE_OS::condattr_setclock () - method. - -. Added TIME_POLICY support to ACE_Condition_Attributes to allow for - monotonic timer support for ACE_Condition. - -. Added TIME_POLICY support to ACE_Message_Queue-s, ACE_Task-s and - related classes to enable support for monotonic timers in the timed - wait methods (ACE_Condition based). See docs/ACE-monotonic-timer.html - for how to use this. - -. Added two new regression tests: - Monotonic_Task_Test - Monotonic_Message_Queue_Test - and updated the Bug_4055_Regression_Test to a fixed state. - -USER VISIBLE CHANGES BETWEEN ACE-6.1.2 and ACE-6.1.3 -==================================================== - -. Added support for Oracle Solaris Studio 12 Update 3 (SunCC 5.12) - -. Added new XML_Utils library which comes from DAnCE but is now also used - by OpenDDS - -USER VISIBLE CHANGES BETWEEN ACE-6.1.1 and ACE-6.1.2 -==================================================== - -. Added compile time support for Windows CE 7, no runtime testing has - been performed - -. The High Res Timer global scale factor on Windows is now 64bit, see bugzilla - 3703 for the background of this. If you use the gsf in your code, use the - new ACE_High_Res_Timer::global_scale_factor_type type trait to not get - any conversion warnings - -. Removed Tandem NSK v2/v3 support which resulted in cleanup throughout all - code. The emulations for ACE_INT64/ACE_UINT64 have been removed because no - platform is using them anymore - -USER VISIBLE CHANGES BETWEEN ACE-6.1.0 and ACE-6.1.1 -==================================================== - -. Minor bug fixes - -USER VISIBLE CHANGES BETWEEN ACE-6.0.8 and ACE-6.1.0 -==================================================== - -. Added compilation support for VxWorks 6.9, no runtime - testing has been performed - -. Added ACE Run-length encoding compressor - -. Fixed several Coverity reported issues - -USER VISIBLE CHANGES BETWEEN ACE-6.0.7 and ACE-6.0.8 -==================================================== - -. Added support for MPC's new feature that creates dependency files for IDL - files when generating '-type gnuace' projects. Turned off by default, it - can be enabled in a features file or on the command line with - '-features ace_idl_dependencies=1'. - -USER VISIBLE CHANGES BETWEEN ACE-6.0.6 and ACE-6.0.7 -==================================================== - -. Added a new method to ACE_Atomic_Op, TYPE exchange (TYPE newval) - which does an atomic exchange of the new value with ACE_Atomic_Op's value - and returns the old value. The tests/Atomic_Op_Test.cpp test program has a - test case that exemplifies its usage; see the Exchange_Tester class. - -. Added a new feature to timer queue templates classes: TIME_POLICY. - This feature is specified through a new template argument and provides the - timer queue with a policy for a timer (time of day) value. This feature is - intended to replace (in time) the gettimeofday setter method which has been - marked @deprecated. For now backwards compatibility is guaranteed. - The TIME_POLICY feature provides flexibility with regards to providing a timer - source to the timer queues as well as the possibility for a fully optimized - calling path. - A number of standard time policies are provided in ace/Time_Policy.h. - The tests/Timer_Queue_Test.cpp has been updated to reflect and exemplify these - changes. - -. Added the TIME_POLICY feature also to countdown time class which has now - become a template (ace/Countdown_Time_T.h) - -. Initial support for Microsoft Visual Studio 11 - -. Increased overall code quality by using Coverity and Klocwork - -USER VISIBLE CHANGES BETWEEN ACE-6.0.5 and ACE-6.0.6 -==================================================== - -. Removed autoconf support, only traditional way of - compilation is shipped from now - -. Add support for RHEL 6.1 64bit - -USER VISIBLE CHANGES BETWEEN ACE-6.0.4 and ACE-6.0.5 -==================================================== - -. Improved support for Android and added the ability to run all ACE/TAO tests - automatically using the Android emulator - -USER VISIBLE CHANGES BETWEEN ACE-6.0.3 and ACE-6.0.4 -==================================================== - -. Removed support for C++ Builder - -. Added support for building with the Android NDK, at least r5c. This - is currently available for linux host platforms. - -USER VISIBLE CHANGES BETWEEN ACE-6.0.2 and ACE-6.0.3 -==================================================== - -. Added support for GCC 4.6 - -USER VISIBLE CHANGES BETWEEN ACE-6.0.1 and ACE-6.0.2 -==================================================== - -. The ACE_wrappers/ace/OS.h file has been restored in order to ensure - build-time compatibility with older ACE versions. Its use will still - cause your build to incur more processing time than using the needed - ace/OS_NS_*.h files; however, you should be able to build OS.h-including - code without needing to replace it with OS_NS_* includes. - -. Improved and simplified QNX support - -. Changed rand_r() and getpwnam_r() to conform Single UNIX Specification. - -. Fixed performance of send_v on windows when individual iovec elements - are particularly large. - -USER VISIBLE CHANGES BETWEEN ACE-6.0.0 and ACE-6.0.1 -==================================================== - -. Added support for MinGW with GCC 4.5 - -USER VISIBLE CHANGES BETWEEN ACE-5.8.3 and ACE-6.0.0 -==================================================== - -. Changed the string format produced by ACE::timestamp() from the ctime - format "Day Mon dd hh:mm:ss yyyy" to ISO-8601 yyyy-mm-dd hh:mm:ss.mmmmmm. - This makes the time easier to collate and removes any dependence on locale. - The change affects the output from ACE_Log_Msg's %D format and both VERBOSE - and VERBOSE_LIGHT timestamps in addition to application-made direct calls - to ACE::timestamp(). - -. Removed GCC < 3 support - -. A new build system hook was added for users to include site-private rules - in a build. If a file named "rules.private.GNU" in located in any build - directory it will get included from - $ACE_ROOT/include/makeinclude/rules.local.GNU. The "private_rules_file" - make variable can be set to override the name and/or location of the file. - If no such rules file exists, its absence is silently ignored. This - facility can be used, for example, to integrate a specialized code checker - into the build process. - -USER VISIBLE CHANGES BETWEEN ACE-5.8.2 and ACE-5.8.3 -==================================================== - -. Two new methods were added to ACE_Pipe: close_read() and close_write(). - These methods can be used to close individual pipe handles. - -. The ACE::handle_ready() family of methods was changed to prefer using - poll() over select() on platforms where poll() is available. This - preference was previously only used if ACE_HAS_LIMITED_SELECT was set. - The ACE_HAS_LIMITED_SELECT choice is removed, making ACE_HAS_POLL the - setting that switches this preference. The driving reason for this - is that if select() is called to detect changes on a handle whose - values falls outside that which can safely be stored in an fdset, - the handle-setting macros/functions will set/clear bits outside - of the fdset. This results in very weird memory changes, often in - the stack, which are very hard to diagnose. poll()'s operation - does not suffer from this affect. With the growing use of large - numbers of handles and use of ACE_Dev_Poll_Reactor on Linux, - the rate at which this problem was cropping up was increasing. - -. Added a simple helper ACE::is_equal() which compares equality of two - objects without using operator==. This is useful for comparing floating - point values. - -. Removed all deprecated methods, arguments, files, classes, macros and - anything else we kept for years. - -. Removed Irix/Tru64/SCO/Uniware/Cray support - -. ACE_Pair has been removed. Users should now use std::pair. - -. This is the last micro release that will work with GCC < 3, after x.8.3 - support for GCC < 3 will be removed - -USER VISIBLE CHANGES BETWEEN ACE-5.8.1 and ACE-5.8.2 -==================================================== - -. Added support for the Microsoft Visual Studio 2010 IDE (vc10) - -. Removed complete support for emulated C++ exceptions - -USER VISIBLE CHANGES BETWEEN ACE-5.8.0 and ACE-5.8.1 -==================================================== - -. Added support for Microsoft Visual Studio 2010 using nmake - -. Reduced the amount of doxygen pages generated, the original settings caused - a doxygen generated html package of 1.4GB which was way too large - -. Extended ACE INet addon library with: - * HTTP Basic Authentication - * SSL/HTTPS support. - * Proxy CONNECT tunneling. - -USER VISIBLE CHANGES BETWEEN ACE-5.7.9 and ACE-5.8.0 -==================================================== - -. There are two new ACE_Time_Value methods for getting and setting millisecond - values to/from ACE_UINT64 values: - - ACE_UINT64 ACE_Time_Value::get_msec () const - void ACE_Time_Value::set_msec (const ACE_UINT64 &ms) - - The former is a replacement for the existing msec(ACE_UINT64&) methods that - are "getter" methods whose signatures look confusingly like "setters". See - Bugzilla #3336 for the history behind this change. - - The latter is for consistency and clarity. - -. Added ACE INet addon library for Inet protocol clients (and possibly - servers at some point) like http://, ftp:// etc. - The library implements standard C++ iostream wrapper classes for - ACE Svc_Handler and Reactor based input/output handling, URL classes - and protocol handler classes. - NOTE: This is work in progress! There is no guarentee that the API - won't change in the next few releases. - Protocol handling is currently restricted to client side download - requests for HTTP and FTP. - Handling for upload requests should be added in the near future as well - as HTTP Basic Authentication. - -USER VISIBLE CHANGES BETWEEN ACE-5.7.8 and ACE-5.7.9 -==================================================== - -. ACE's default makefiles (traditional ACE/GNU, not autoconf/automake) - now support installation with "make install". - Please see the ACE-INSTALL.html file for instructions. - -. Support for the ARCH make variable has been enhanced to apply to executables - (in addition to libraries and object files), and the ARCH feature has been - integrated into the MPC-generated makefiles (to work with MPC's requires - and avoids features). - -USER VISIBLE CHANGES BETWEEN ACE-5.7.7 and ACE-5.7.8 -==================================================== - -. ACE now uses GCC builtin Atomic instructions for short, - unsigned short, long, unsigned long, int, unsigned int, - and bool. This makes our Atomic_Op around 7 times faster - -. ACE Service Configuration Framework now process first service - configuration files and then command-line directives. Thus if - application uses both service configuration files and command-line - directives then the command-line directives may override results of - directives in the configuration files. At the same time if the - application uses only the default svc.conf file and command-line - directives then the directives from svc.conf can not override - results of the user provided command-line directives. - -. ACE_Dev_Poll_Reactor now dispatches notifications in only one thread at - a time. This brings notification handling more in line with behavior in - other Reactor implementations. - -USER VISIBLE CHANGES BETWEEN ACE-5.7.6 and ACE-5.7.7 -==================================================== - -. Integrated fix for bug 3104 and regression test for - interval timers. - -. Added support for GCC builtin Atomic instructions which - are enabled with GCC >= 4.1 for PPC32/PPC64/IA64 - -. Improved autoconf support for debian - -. Added support for -mcpu and -mtune. Add TCPU=.. to your - environment/platform_macros.GNU to specify you cpu and - than add cpumodelflag=1 and/or tunemodelflag=1. Using - this with IBM Cell increased the performance significantly - -USER VISIBLE CHANGES BETWEEN ACE-5.7.5 and ACE-5.7.6 -==================================================== - -. Added support for iPhone/iPod Touch/iPad. The following - environment variables are needed: - - IPHONE_TARGET, should be set to either SIMULATOR or - HARDWARE. Set to HARDWARE if you want to deploy - on the iPhone/iPod Touch/iPad device. - - IPHONE_VERSION, should be set to 3.1.2 or 3.2. One can - set the version to any future or past versions, but - only 3.1.2 and 3.2 have been tried. - - Note that one has to compile ACE/TAO statically as - it is believed that the iPhone OS does not support - dynamic loading of external libraries. The usual - procedure of cross compiling ACE/TAO applies - (such as setting HOST_ROOT environment variable). - -. Added support for Embarcadero C++ Builder 2010 - -. Added option to print a given ACE_Time_Value in the log - message instead of system supplied timestamp as in %T - and %D. - The option is implemented as a variant of the %D/%T - options by using the '#' flag character like '%#D' or - '%#T'. When using this flag an ACE_Time_Value pointer is - expected in the argument list supplied with the log message. - This fixed Bugzilla #3221. - -. Fixed problems with ACE_INET_Addr::is_multicast() on - little endian platforms. This fixed bugzilla #3729. - -. Added compilation support for VxWorks 6.8, no runtime - testing has been performed - -USER VISIBLE CHANGES BETWEEN ACE-5.7.4 and ACE-5.7.5 -==================================================== - -. Added MacOSX Snow Leopard support - -. Added strsignal() wrapper - -. Improved LynxOS support - -. Updated Interix port - -. Fixed MinGW compilation problems - -USER VISIBLE CHANGES BETWEEN ACE-5.7.3 and ACE-5.7.4 -==================================================== - -. ACE_CDR::consolidate now returns an int, 0 is ok, -1 is failure - -. Fixed a bug in the realclean feature of the GNU makefiles - -. Improved Sun Studio for Linux support - -. Improved OpenBSD support - -USER VISIBLE CHANGES BETWEEN ACE-5.7.2 and ACE-5.7.3 -==================================================== - -. C++ Builder 2009 Update 3 is the only C++Builder that is supported, older - and newer compilers are not supported anymore - -. Made final changes for the CEGCC port - -. Added a set of tests to validate C++ compiler and the stl implementation - they ship. - -. HP-UX PARISC aCC < 3.80 are deprecated and can't be used anymore. Upgrade - to aCC 3.80 or newer - -USER VISIBLE CHANGES BETWEEN ACE-5.7.1 and ACE-5.7.2 -==================================================== - -. Borland C++ makefiles aren't shipped anymore as part of the release - but have to be generated by the user - -. Refactored gperf to have its own shared library so that we can reuse - that in TAO - -. Added support for SuSE Enterprise 10 - -. ACE_Configuration_Heap::open() now returns -1 with errno EBUSY if it is - called multiple times. Previous versions would allow multiple calls to - open() but leak resources. - -USER VISIBLE CHANGES BETWEEN ACE-5.7.0 and ACE-5.7.1 -==================================================== - -. Added support for Sun Studio 12 Update Pack 1 - -. Fixed compile problems when using Windows CE x86 release mode - -. Fixed compile problems for FreeBSD - -USER VISIBLE CHANGES BETWEEN ACE-5.6.9 and ACE-5.7.0 -==================================================== - -. Added support for the VxWorks vxAtomicLib which is available with VxWorks 6.6 - and newer. If you don't want to use this library undef ACE_HAS_VXATOMICLIB - in your config.h file - -. Added support for C++ Builder 2009 Update 3 - -. Added support for ACE/TAO using the CEGCC project - -. Added support for upcoming Fedora 11 and OpenSuSE Factory - -USER VISIBLE CHANGES BETWEEN ACE-5.6.8 and ACE-5.6.9 -==================================================== - -. Removed Borland/CodeGear C++ Builder 2007 support. If you'd like to - fund this support please let us know. - -. Removed VxWorks 5.5.x, 6.2, and 6.3 support. If you'd like to fund - this support please let us know. - -. Improved Unicode support. - -. Added support for the native Windows Vista and Windows Server 2008 - condition variables. These has to be enabled at compile time, and when - enabled the application can only run on Vista or Server 2008. Add - ACE_HAS_WTHREADS_CONDITION_VARIABLE to your config.h file to enable - these - -. Fixed a bug when trying to read a file of 1 byte when unicode is - enabled - -. Improved the Windows CE port - -. Fixed several Klocwork reported issues - -. Added support for MinGW 3.15 - -. Added support for Incredibuild, which is an MSVC++ feature that - optimizes compiles via distributing builds. - -USER VISIBLE CHANGES BETWEEN ACE-5.6.7 and ACE-5.6.8 -==================================================== - -. Added a new function ACE::isdotdir() which determines if a specified - pathname is "dot dir" (ie. "." or ".."). ACE::isdotdir() is significantly - faster than pair of strcmp() calls. - -. Last micro release that is maintained for Borland/CodeGear C++ - Builder 2007 and Intel C++ on Windows. - -. Fixed crash when ACE thread tries to inherit the logging attributes - from non ACE threads. - -. Fixed many small compile and test errors that occur on some platforms. - -. Fixed log output formatting on some platforms. - -. Bugs fixed: 2748, 3164, 3480, 3494, 3502, 3541, 3542, 3544, 3557. - -USER VISIBLE CHANGES BETWEEN ACE-5.6.6 and ACE-5.6.7 -==================================================== - -. Changed the automake build's feature test for a "usable" config - to warn on failure instead of exiting with an error. This should - make it easier to diagnose configure failures, as the script will - now generate a config.h file even when the test fails. - -. Removed borland MPC template, use the bmake template from now - -. Added Windows Mobile 6 support and improved the WinCE port - -. Removed BCB6 and BCB2006 support - -. Added BCB2009 MPC template - -. Updated stat struct on Windows CE to match the stat struct on other - platforms so that application code can be written portable - -. Added new ACE_OS wrappers: raise, atof, atol, isblank, isascii, - isctype, and iswctype - -. Added ACE_OS wrapper for narrow-char version of strtoll. - -. ACE_OS wrappers for wide-char versions of strtol, strtoul, - strtoll, and strtoll. - -. Added Visual Studio 2010 (vc10) support - -. Added a new feature for the "Traditional Make" build facility to allow - building for multiple architectures out of a single source directory. - To use this facility, set the ARCH make variable. The ARCH value will be - used to add a subdirectory layer below the source directory where the - traditional .shobj, .obj, etc. directories will be placed. - -. Added support for HP-UX 11iv3 on Integrity using aC++ - -. ACE (and TAO) can now be built using GNU make and the Microsoft Visual C++ - compiler and linker. See include/makeinclude/platform_win32_msvc.GNU for - more details. - -. Added support for FC10 - -USER VISIBLE CHANGES BETWEEN ACE-5.6.5 and ACE-5.6.6 -==================================================== - -. Added an option to the ACE_Process_Options class to use a wchar_t - environment buffer on Windows. - -. A new configure option, --enable-rcsid, was added to the autoconf build. - This is used to embed RCS IDs in object files. - -. A new method was added: void ACE_Time_Value::msec (ACE_UINT64&) - This method, like the existing msec(ACE_UINT64&)const method, obtains the - time value in milliseconds and stores it in the passed ACE_UINT64 object. - This method was added so that msec(ACE_UINT64&) can be called on both - const and non-const ACE_Time_Value objects without triggering compile errors. - Fixes Bugzilla #3336. - -. Added ACE_Stack_Trace class to allow users to obtain a stack trace - within their application on supported platforms. A new conversion - character, the question mark, was added to ACE_Log_Msg for stack - trace logging. - -. Added iterator support to ACE_Message_Queue_Ex class. The resulted in - the addition of ACE_Message_Queue_Ex_Iterator class and - ACE_Message_Queue_Ex_Reverse_Iterator class. - -. Renamed gperf to ace_gperf to prevent clashes with the regular gperf - tool that is available in linux distributions - -. Added support for FC9 - -. Added support for OpenSuSE 11.0 - -. Improved support for GCC 4.2 and 4.3 - -. Added support for CodeGear C++ Builder 2009 - -USER VISIBLE CHANGES BETWEEN ACE-5.6.4 and ACE-5.6.5 -==================================================== - -. Added new Monitoring lib that can be used to store and retrieve - counters. This is disabled by default because it is not 100% - finished yet, with the next release it will be enabled by default - -. Fixed bug in ACE_Service_Config when it was used from a thread - not spawned by ACE - -. Add VxWorks 6.x kernel mode with shared library support to ACE - -. Extended the implementation of Unbounded_Set, which has been - renamed Unbounded_Set_Ex, to accept a second parameter which is - a comparator that implements operator() which returns true if - the items are equivalent. Unbounded_Set has been reimplemented - in terms of Unbounded_Set_Ex using a comparator that uses operator==, - which captures the previous behavior. - -. Added support for Intel C++ on MacOSX - -USER VISIBLE CHANGES BETWEEN ACE-5.6.3 and ACE-5.6.4 -==================================================== - -. Reworked the relationship between ACE_Service_Config and - ACE_Service_Gestalt - -. Improved autoconf support - -. Improved AIX with gcc support - -. Improved OpenVMS support - -. Improved VxWorks support - -USER VISIBLE CHANGES BETWEEN ACE-5.6.2 and ACE-5.6.3 -==================================================== - -. Deprecated Visual Age 5 and older - -. Closed a rare race condition hole whereby ACE_Atomic_Op<> function - pointers would not be fully initialized prior to use. See bugzilla - 3185 for details. - -. Tweaks to support MacOS X Leopard (10.5 and 10.5.1) on Intel - -. Fixed compile problems with MinGW with GCC 4.2. Do note that we do see - much more test failures then when using GCC 3.4. - -. Changed to use synchronous exception handling with msvc 8/9 which is the - default. Asynchrous exception handling does catch access violations but - it leads to lower performance and other problems. See also bugzilla 3169 - -. Make ace_main extern C with VxWorks so that it doesn't get mangled - -. Fixed compile errors and warnings for VxWorks 6.6 - -. Added an MPC generator for the WindRiver Workbench 2.6 which is shipped - with VxWorks 6.4 - -. Added support for CodeGear C++ Builder 2007 with December 2007 update - installed - -. Added support for VxWorks 5.5.1 - -. Implemented the const reverse iterator for ACE_Hash_Map_Manager_Ex - -. Increased support for using ACE_Hash_Map_Manager_Ex with STL - functions based on latest standard C++ draft - -USER VISIBLE CHANGES BETWEEN ACE-5.6.1 and ACE-5.6.2 -==================================================== - -. ACE-ified the UUID class, which will change user applications slightly. - -. Added support for Sun Studio 12 - -. Added support for Intel C++ 10.1 - -. Fixed runtime problems with VxWorks 6.x in kernel mode, several improvements - have been made to ACE, but also some problems in the VxWorks kernel have - been found for which WindRiver has made patches. - -. Added support for VxWorks 6.5 kernel mode - -. Added support for MacOS 10.5 - -. Support for MacOS 10.4 is now deprecated. - -. Added support for OpenSuSE 10.3 - -. Added support for RedHat 5.1 - -. Added support for Microsoft Visual Studio 2008 - -. Added support for Fedora Core 8 - -. Added support for Ubuntu 7.10 - -. With Ubuntu 7.04 and 7.10 we can't use visibility, that results in - unresolved externals when building some tests. With lsb_release we - now detect Ubuntu 7.04 and 7.10 automatically and then we disable - visibility - -. Removed deprecated (un)subscribe methods from ACE_SOCK_Dgram_Mcast - -. Added an additional replace() method to ACE_OuptutCDR for replacing a - ACE_CDR::Short value. Also added write_long_placeholder() and - write_short_placeholder() to properly align the stream's write pointer, - write a placeholder value and return the placeholder's pointer. The pointer - can later be used in a call to replace() to replace the placeholder with a - different value. - -. Initial support for VxWorks 6.6 - -. Removed support for pthread draft 4, 6, & 7. This makes the ACE threading - code much cleaner - -. Improved autoconf support - -. Fixed TSS emulation problems - -. Changed ACE_thread_t and ACE_hthread_t to int for VxWorks kernel mode. All - thread creation methods do have an additional const char* argument to - specify the task name, this now also works with pthread support enabled - -. Use bool in much more interfaces where this is possible - -. Added support for Debian Etch - -. Fixed ACE CDR LongDouble support on VxWorks 6.x - -. Added Microsoft Visual Studio 2008 project files to the release packages - -. Fixed a few bugs in the ACE_Vector template - -USER VISIBLE CHANGES BETWEEN ACE-5.6 and ACE-5.6.1 -==================================================== - -. Added support for CodeGear RAD Studio 2007 - -. Added support for CodeGear C++ Builder 2007 Update 3 - -. Modified the definiton of ACE_DEFAULT_THREAD_KEYS on Windows so it - is based on the version of the OS as defined by Microsoft in this web - page: http://tinyurl.com/2jqcmd - This fixes bugzilla #2753 - -USER VISIBLE CHANGES BETWEEN ACE-5.5.10 and ACE-5.6 -==================================================== - -. OpenVMS 8.3 on IA64 port - -. Added autoconf support for Intel C++ 10.0 - -. Improved autoconf support on Linux, Solaris, NetBSD and HPUX - -. CodeGear C++ Builder 2007 Update 2 support - -. The netsvcs's client logging daemon has a new configuration option, - -llocal-ip[:local-port], which can be used to specify the local IP - address and port number for the client logging daemon's connection to - the server logging daemon. If the -l option is specified with an IP - address but not a port number, an unused port number is selected. - -. A new ACE+TAO port to LabVIEW RT 8.2 with Pharlap ETS. The host build - environment is Windows with Microsoft Visual Studio .NET 2003 (VC7.1). - Please see the ACE-INSTALL.html file for build instructions. - -USER VISIBLE CHANGES BETWEEN ACE-5.5.9 and ACE-5.5.10 -==================================================== - -. The ACE_utsname struct, used in the ACE_OS::uname() function when the - platform doesn't provide the standard utsname struct, was changed. It - defines a number of text fields and their types were changed from - ACE_TCHAR[] to char[] in order to be consistent with all other platforms. - This removes the need to write different code for platforms where - ACE_LACKS_UTSNAME_T is set and that have wide characters (most probably - Windows). Fixes Bugzilla #2665. - -. The ACE::daemonize() "close_all_handles" parameter was changed from - an "int" to a "bool" to better reflect how it is used. - -. VxWorks 6.5 support. Compilation of the core libraries has been validated - but no runtime testing has been performed. - -. CodeGear C++ Builder 2007 support. - -. The FaCE utility was moved from the ACE_wrappers/apps directory to - ACE_wrappers/contrib. It is used for testing ACE+TAO apps on WinCE. - See the ACE_wrappers/contrib/FaCE/README file for more information. - -. ACE_INET_Addr::set (u_short port, char *host_name, ...) now favors IPv6 - addresses when compiled with ACE_HAS_IPV6 defined and the supplied address - family is AF_UNSPEC. This means that if host_name has an IPv6 address in - DNS or /etc/hosts, that will be used over an IPv4 address. If no IPv6 - address exists for host_name, then its IPv4 address will be used. - -. Intel C++ 10.0 support - -. Support for the version of vc8 for 64-bit (AMD64) shipped with the Microsoft - Platform SDK. - -. Fixed ACE_Vector::swap() (bugzilla #2951). - -. Make use of the Atomic_Op optimizations on Intel EM64T processors. The - Atomic_Op is now several times faster on EM64T then with previous versions - of ACE - -USER VISIBLE CHANGES BETWEEN ACE-5.5.8 and ACE-5.5.9 -==================================================== - -. Use Intel C++ specific optimizations for Linux on IA64 - -. Improved support for ACE_OS::fgetc. Added support for ACE_OS::fputc, - ACE_OS::getc, ACE_OS::putc and ACE_OS::ungetc. - -. Added support for ACE_OS::log2(double) and improved support for - ACE::log2(u_long). - -. Shared library builds on AIX now produce a libxxx.so file instead of the - previous practice of producing libxxx.a(shr.o). - -. GCC 4.1.2 that comes with Fedora 7 seems to have a fix for the visibility - attribute we use for the singletons. F7 users will therefore need to - define the following in your config.h file. - ACE_GCC_HAS_TEMPLATE_INSTANTIATION_VISIBILITY_ATTRS 1 - -. Fixed (rare) problem in TP_Reactor where incorrect event handler was - resumed. - -. Reduced footprint on some platforms, particularly those that use - g++ >= 3.3. - -USER VISIBLE CHANGES BETWEEN ACE-5.5.7 and ACE-5.5.8 -==================================================== - -. Extended ACE_Event constructor with optional LPSECURITY_ATTRIBUTES - argument - -. Added support for QT4 - -. Added support to integrate with the FOX Toolkit (www.fox-toolkit.org) - -. Added support for Microsoft Visual Studio Code Name "Orcas", which is - the msvc9 beta - -. Added ability to provide an optional priority when calling - ACE_Message_Queue_Ex::enqueue_prio(). There was previously no way - to specify a priority for queueing. - -. Removed support for Visual Age on Windows. - -. ACE will compile once again with ACE_LACKS_CDR_ALIGNMENT #defined. - -. ACE_Process_Manager::terminate() no longer removes the process from the - process descriptor table; the pid remains available in order to call - ACE_Process_Manager::wait(). - -USER VISIBLE CHANGES BETWEEN ACE-5.5.6 and ACE-5.5.7 -==================================================== - -. ACE 5.5 contained a set of pragmas which prevented Visual Studio 2005 (VC8) - from issuing warnings where C run-time functions are used but a more - secure alternative is available. For more information on the C run-time - issues and Microsoft's response, please see the following MSDN page: - http://msdn2.microsoft.com/en-us/library/8ef0s5kh(VS.80).aspx. - In this beta, the pragmas which prevented the warnings have been removed. - The ACE library has been reviewed and most of the use of "unsafe" functions - has been fixed where possible. Since not all of the warnings emanating from - ACE are situations that can or should be fixed, the ACE VC8 projects will - prevent the warnings while building the ACE kit and its contained examples, - tests, etc. The warnings are disabled by adding Microsoft-specified macros - to the compile line via MPC. If desired, the warnings can be re-enabled by - regenerating the project files with different MPC features. Note, however, - that while ACE without warnings caused by the new C run-time functions, your - application builds may trigger these warnings either by use of the "unsafe" - C run-time functions or via use of an inlined ACE_OS method which uses it. - If the warning is caused by an ACE_OS method, there is a more safe alternate - available, probably located by appending _r to the method name (e.g., - instead of using ACE_OS::ctime(), use ACE_OS::ctime_r()). - There are other cases where the compiler may have issued warnings and ACE - prevented this via a #pragma. These #pragmas have been removed as well. - This may cause your application builds to trigger more warnings from VC8 - than past ACE versions. You should review your code and either correct - the code or disable the warnings locally, as appropriate. - -. The "release" argument to a number of ACE_String_Base<> methods was changed - from int to bool to more accurately reflect its purpose. The following - methods were changed: - - ACE_String_Base (const CHAR *s, - ACE_Allocator *the_allocator = 0, - int release = 1); - to - ACE_String_Base (const CHAR *s, - ACE_Allocator *the_allocator = 0, - bool release = true); - - ACE_String_Base (const CHAR *s, - size_type len, - ACE_Allocator *the_allocator = 0, - int release = 1); - to - ACE_String_Base (const CHAR *s, - size_type len, - ACE_Allocator *the_allocator = 0, - bool release = true); - - void set (const CHAR * s, int release = 1); - to - void set (const CHAR * s, bool release = true); - - void set (const CHAR * s, size_type len, int release); - to - void set (const CHAR * s, size_type len, bool release); - - void clear (int release = 0); - to - void clear (bool release = false); - - Since ACE_String_Base forms the basis of the ACE_CString and ACE_TString - classes, this may ripple out to user application code. If you encounter - errors in this area while building your applications, replace the - int argument you are passing to the method now with either true or false. - -. Solutions for the eVC3/4 platform have been removed from this - release. Note that we package WinCE projects/workspaces for use - with VC8. - -. There were 3 new ACE_Log_Msg logging format specifiers added to make logging - easier for types that may change sizes across platforms. These all take one - argument, and the new formats are: - %b - format a ssize_t value - %B - format a size_t value - %: - format a time_t value - -. The ace/Time_Request_Reply.h and ace/Time_Request_Reply.cpp files were - moved from $ACE_ROOT/ace to $ACE_ROOT/netsvcs/lib. The time arguments in - the public API to ACE_Time_Request were changed from ACE_UINT32 to time_t - and the portions of the on-wire protocol that contains time was changed from - ACE_UINT32 to ACE_UINT64. Thus, code that uses the ACE_Time_Request class - to transfer time information will not interoperate properly with prior - ACE versions. This will affect uses of the netsvcs time clerk/server. - -. The portion of the ACE_Name_Request class that carries the on-wire seconds - portion of a timeout value was changed from ACE_UINT32 to ACE_UINT64. This - means that Name server/clients at ACE 5.5.7 and higher will not interoperate - properly with previous ACE versions' name servers/clients. - -. In the ACE_Log_Record (ACE_Log_Priority, long, long) constructor, the - second argument, long time_stamp, was changed to be of type time_t. This - aligns the type with the expected value, a time stamp such as that returned - from ACE_OS::time(). - -. Added support for VxWorks 6.x cross compilation using a Windows host - system - -. Added support for VxWorks 6.x using the diab compiler - -. The destructor of ACE_Event_Handler no longer calls - purge_pending_notifications(). Please see bugzilla #2845 for the full - rationale. - (http://deuce.doc.wustl.edu/bugzilla/show_bug.cgi?id=2845) - -USER VISIBLE CHANGES BETWEEN ACE-5.5.5 and ACE-5.5.6 -==================================================== - -. The ACE_TYPENAME macro has been added to those that are not - available when the ACE_LACKS_DEPRECATED_MACROS config option is set - (it is not set by default). You are encouraged to replace the use of - ACE_TYPENAME with the C++ typename keyword before the ACE_TYPENAME - macros is removed from ACE in the future. - -. A new script, rm_exception_macros.pl, has been added to help users - remove the use of the ACE exception macros from their own code. - -USER VISIBLE CHANGES BETWEEN ACE-5.5.4 and ACE-5.5.5 -==================================================== - -. The prebuild MPC keyword is now supported by the gnuace project type. - This fixes Bugzilla #2713. - -. Support for Windows earlier than NT 4 SP2 was removed. ACE will not build - for Windows 95, 98, Me, etc. out of the box any longer. - -. Reformat stringified IPv6 addresses to use [addr]:port when printing - addresses that contain ':' such as "::1". - -. Added method to ACE_INET_Addr to determine if address is IPv6 or - IPv4 multicast. - -. Fixed a bug in ACE_Async_Timer_Adapter_Timer_Queue_Adapter where the - gettimeofday function of the timer queue was ignored when setting the alarm. - -. Fixed a problem where, on Solaris 9 onwards, calling - ACE_OS::thr_create(THR_NEW_LWP) more than 2^15 (65535) times in a - process will fail. See changelog entry from "Wed Jan 3 22:31:05 UTC - 2007 Chris Cleeland " for more information. - -. Fixed a bug in ACE_QtReactor where the two select() calls in that function - might select on different handler sets. - -. ACE_SOCK_IO::recvv(iovec[], size_t, const ACE_Time_Value* = 0) and - ACE_SOCK_IO::sendv (const iovec[], size_t, const ACE_Time_Value* = 0) methods - were changed to specify the iovec count argument as int instead of size_t - since it gets reduced to int in the underlying OS calls (usually). - -. The following deprecated methods were removed: - - ssize_t ACE_SOCK_IO::recv (iovec iov[], - size_t n, - const ACE_Time_Value *timeout = 0) const; - - ssize_t ACE_SOCK_IO::recv (iovec *io_vec, - const ACE_Time_Value *timeout = 0) const; - - ssize_t ACE_SOCK_IO::send (const iovec iov[], - size_t n, - const ACE_Time_Value *timeout = 0) const; - - These were previously replaced with more specific recvv() and sendv() - methods. - -. The ACE_Service_Repository::find(const ACE_TCHAR name[], - const ACE_Service_Type **srp = 0, - int ignore_suspended = true) const - method's 'ignore_suspended' parameter was changed from int to bool to - reflect it's purpose as a yes/no indicator. - -. Added --enable-ace-reactor-notification-queue configure script - option to the autoconf build for enabling the Reactor's userspace - notification queue (defines ACE_HAS_REACTOR_NOTIFICATION_QUEUE in - config.h). - -. The int ACE_OutputCDR::consolidate(void) method was contributed by - Howard Finer at Sonus Networks. This method consolidates any continuation - blocks used by an ACE_OutputCDR object into a single block. It's useful for - situations which require access to a single memory area containing the - encoded stream, regardless of its length, when the length cannot be known - in advance. - -. There are a number of new methods defined on ACE_String_Base: - - size_t capacity (void) const: This method returns the number - of allocated CHAR units in the string object. - - void fast_resize (size_t): This method manage the sizing/reallocating - of the string, but doesn't do the memory setting of resize(). - - bool operator!= (const CHAR *) const - bool operator== (const CHAR *) const: These methods compare the - string with a nul-terminated CHAR* string. - - nonmember functions operator== and operator!= where also added - that compare const ACE_String_Base and const CHAR*; these make - it possible to switch ACE_String and CHAR* on either side of - the operator. - - Thank you to Kelly Hickel for these additions. - -. There are 2 new build options on the traditional make command: - dmalloc and mtrace. When specified at build time (e.g. make mtrace=1) - the PLATFORM_DMALLOC_CPPFLAGS and/or PLATFORM_MTRACE_CPPFLAGS values - are added to CPPFLAGS. For dmalloc, the PLATFORM_DMALLOC_LDFLAGS and - PLATFORM_DMALLOC_LIBS are added to LDFLAGS and LIBS, respectively. - Thank you to Howard Finer for supplying these additions. - -. Added the ability to specify additional purify and quantify command-line - options by setting PLATFORM_PURIFY_OPTIONS and PLATFORM_QUANTIFY_OPTIONS, - respectively. Thank you to Howard Finer for supplying these additions. - -. Added the ability to use trio (http://sourceforge.net/projects/ctrio/) - if platform lacks decent support for vsnprintf. trio support is - enabled by defining trio=1 in plaform_macros.GNU - -. Removed Irix 5, DGUX, and m88k support - -. Improved LynxOS 4.2 support - -. VxWorks 6.4 support - -. Added support for FC6. Because the GCC 4.1.1 version that gets shipped - has a fix for the visibility attribute we use for the singletons - you will need to define the following in your config.h file. This can't be - done automatically because SuSE 10.2 gets shipped with GCC 4.1.2 but - doesn't have the same fix - ACE_GCC_HAS_TEMPLATE_INSTANTIATION_VISIBILITY_ATTRS 1 - -. RTEMS port - -USER VISIBLE CHANGES BETWEEN ACE-5.5.3 and ACE-5.5.4 -==================================================== - -. Added appropriate intptr_t and uintptr_t typedefs on platforms that - don't provide them (i.e. when ACE_LACKS_INTPTR_T is defined). - -. Added ability to explicitly choose support for 32 bit or 64 bit file - offsets on all platforms. Define the _FILE_OFFSET_BITS preprocessor - symbol to either 32 or 64 to choose the desired number of file - offset bits. This preprocessor symbol is supported natively by most - UNIX and UNIX-like operating systems, and supported by ACE on - Windows. Use the new ACE_OFF_T typedef to refer to file offsets - across UNIX and Windows portably. - -. 64-bit file offsets are now enabled by default in Win64 - configurations. - -. Improved support for 64 bit platforms (64 bit addresses, etc). - -. Added STL-style traits, iterators and a swap() method to the - ACE_Array_Base<> class template. - -. Added STL-style traits and iterator accessors to the - ACE_Hash_Map_Manager_Ex<> class template, as well as new find() and - unbind() methods that return (as an "out" parameter) and accept - iterators, respectively. - -. Greatly improved event handler dispatch performance in - select()-based reactors (e.g. ACE_Select_Reactor and ACE_TP_Reactor) - for large handle sets on Windows. Previous event handler search - were linear, and are now constant on average. - -. Addressed a number of Coverity errors (CHECKED_RETURN, DEADCODE, - LOCK, USE_AFTER_FREE, RESOURCE_LEAK, FORWARD_NULL). - -. Added STL-style "element_type" trait to all ACE auto_ptr class - templates. - -. Removed support for LynxOS 3.x. - -. Resolved Bugzilla #2701 to ensure fini() is called for all - Service Objects upon calling ACE_Service_Config::close() - -. VxWorks 5.5.2 has been tested, for ACE the support is exactly - the same as for VxWorks 5.5.1. No specific defines or flags have - to be used. - -USER VISIBLE CHANGES BETWEEN ACE-5.5.2 and ACE-5.5.3 -==================================================== - -. Added the base projects for executionmanager_stub and plan_generator. - -. Added the ACE_Hash_MultiMap_Manager class and its test file. - -. Changed the ACE_Synch_Options::operator[] method to return bool rather than - int. The value returned is a yes/no indication of whether or not the - specified option(s) are set in the object. - -. Changed the prototype(s) for ACE::debug () to return (and take) a - bool. This is consistent with the original intent for this - feature. If you have been using it like 'ACE::debug () > 0' or - 'ACE::debug (1)', you may have to rebuild ACE. The value of the - ACE_DEBUG environment variable can be used to specify the initial - value for ACE::debug(), at the process start up. - -. An assembler (within a C source file) based implementation for SPARC - of atomic operations suitable for use with the - ACE_Atomic_Op and - ACE_Atomic_Op specializations has - been added. Currently, it can only be enabled by setting the - atomic_ops_sparc make macro to 1 when using the GNUACE build system with - the Solaris SunCC compiler. It should be noted that this requires the - -xarch=v8plus (or higher) be added to the CFLAGS make macro or the - assembler code will not compile. - -. The ACE_Message_Queue_Ex_N class - is new, contributed by Guy Peleg . - ACE_Message_Queue_Ex_N is - similar to ACE_Message_Queue_Ex in that the object queued is a - template parameter. However, ACE_Message_Queue_Ex_N allows the - enqueueing and dequeueing of multiple chained objects at once. This - wasn't added to ACE_Message_Queue_Ex because the chained object - functionality requires the ACE_MESSAGE_TYPE class to have a - ACE_MESSAGE_TYPE *next (void) const method, analogous to - ACE_Message_Block::next(), to follow the chain and this would - probably break existing applications using ACE_Message_Queue_Ex. - The ACE_wrappers/tests/Message_Queue_Test_Ex.cpp test has an example of - how to use the new class. - -. The selector and comparator function pointer arguments to ACE_OS::scandir() - and ACE_Dirent_Selector are now marked as extern "C" to enforce their - use with a C RTL function. User code that defines functions which are - passed as the selector or comparator arguments which are not declared - extern "C" may generate compile warnings. To resolve this, add extern "C" - to the function's signature. See ACE_wrappers/tests/Dirent_Test.cpp for - an example. - -. To address a problem in the ACE string interface that prevented - substring or character searches in very large strings (e.g. greater - than the maximum value of an ssize_t type) from being correctly - reported to the caller, the find(), rfind() and strstr() methods now - return an unsigned integer (size_t) instead of a signed one - (ssize_t). Affected classes include: - - * ACE_CString - * ACE_WString - * ACE_TString - * ACE_NS_WString - - Unless you have been explicitly using -1 instead of npos when - comparing the return value of find(), rfind() and strstr(), and/or - assigning the return value to ssize_t you should not see any - difference. A new size_type typedef has been added to the ACE string - class to aid developers. This typedef is analogous to the standard - C++ string::size_type typedef. - - The ACE_String_Base<>::strstr() documentation and the default - rfind() argument erroneously referred to -1 instead of npos. Those - instances have been corrected. - - To summarize, a "no position" condition is denoted using the npos - constant, not -1. It can be referred directly by scoping it with the - appropriate string class (e.g. ACE_CString::npos, ACE_WString::npos, - etc). - -. Changing the shared library extension for hpux ia64 to ".so". On - HP-UX 11i Version 1.5 the naming scheme is lib*.sl for PA and - lib*.so on IPF. - -. The ACE_Refcounted_Auto_Ptr reset() and release() methods were changed - per Bugzilla #1925. They will both now detach from the underlying - ACE_Refcounted_Auto_Ptr_Rep object; reset() will create a new one for - the new pointer specified as its argument. This change may cause referenced - objects to be deleted in cases where previous ACE versions would not have. - -. The return type of "ACE_Refcounted_Auto_Ptr::null (void) const" changed - from int to bool. It's possible values, true and false, have not changed. - -. TTY_IO now accepts "none" as a valid parity value. Due to this change - 'parityenb' member is now deprecated and will be removed in the future. - The users of TTY_IO class should change their code to use only 'paritymode' - member for parity control and leave 'parityenb' unchanged (it is - enabled by default in class constructor). - -. Support for Intel C++ 9.1 on Windows and Linux - -. VxWorks 6.3 support - -. Fixed Bugzilla #2648 to make sure ACE_Service_Object::fini() - is called iff ACE_Service_Object::init() succeeded, as per - C++NPv2. - -. Added preliminary support for Mac OS X 10.4 on Intel CPU's. - -. Fixed Bugzilla #2602 to re-enable XML Service Configurator - file support. - -USER VISIBLE CHANGES BETWEEN ACE-5.5.1 and ACE-5.5.2 -==================================================== - -. Added support for: - - VxWorks 6.2 for the rtp model using pthread support - - OpenVMS 8.2 for Alpha - -. Removed code and configurations that provided support for: - - Visual C++ 6.0 and 7.0 - - Chorus - - pSOS - - KAI C++ on all platforms - -. Explicit template instantiation support has been removed. This effectively - removes support for Sun Forte 6 and 7 which required explicit template - instantiation to build ACE reliably. - -. Added support for multiple independent Service Repositories through - configuration contexts called "Gestalt". Full backwards compatibility - is maintained through the existing ACE_Service_Config static methods, - while direct individual repository access is enabled through instances - of the new ACE_Service_Gestalt class. ACE_Service_Config has changed to - a specialization of ACE_Service_Gestalt and is only responsible for the - process-wide configuration. - -. To support dynamically-sized ACE_Log_Record messages, the netsvcs - logging components now use ACE CDR encoding and transfer mechanisms - inspired by the examples in Chapter 4 of the C++NPv1 book. - The client and server logging daemons in ACE 5.5.2 and forward will - not interoperate with those in previous ACE versions. - -. Added a wrapper for the sendfile API (ACE_OS::sendfile()). - -. Added support for netlink sockets on Linux. - -. Added a new method, ACE_Task::last_thread(). This method returns the thread - ID (ACE_thread_t) of the last thread to exit from the ACE_Task object. - Users checking to see if a thread is the last one out (for example, to know - when to perform cleanup operations) should compare the current thread ID to - the return value from last_thread(). This is a change from the previously - recommended practice (C++NPv2, page 189) of comparing the return value of - thr_count() with 0. - -. Changed the first argument to ACE_OS::strptime() to be 'const' which - matches its usual usage in POSIX strptime(). This change allows users to - pass const strings in - a common use case. - -. Made part of the file support in ACE 64bit but we have some places where - 32bit types are used, this could lead to some conversion warnings which - will be addressed in the near future, but getting everything 64bit - compliant is a lot of work. - -USER VISIBLE CHANGES BETWEEN ACE-5.5 and ACE-5.5.1 -==================================================== - -. Added support for the --enable-symbol-visibility configure option - to the autoconf build infrastructure instead of solely relying on - feature tests to enable/disable symbol visibility support. This - avoids build problems with icc, etc. - -. Added support for the --enable-fl-reactor configure option to the - autoconf build infrastructure to build the ACE_FlReactor library. - -. Added support for the --enable-qt-reactor configure option to the - autoconf build infrastructure to build the ACE_QtReactor library. - -. Added support for the --enable-xt-reactor configure option to the - autoconf build infrastructure to build the ACE_XtReactor library. - -. Fixed a bug that would cause timer IDs from ACE_Timer_Heap to be - improperly duplicated under certain conditions (Bugzilla #2447). - -. Fixed ACE_SSL_Context::private_key(), context(), and dh_params() methods - to allow retrying a file load after a failed call. - -. Fixed ACE_SSL_Asynch_Stream so it can be instantiated; also moved the - declarations for ACE_SSL_Asynch_Read_Stream_Result, - ACE_SSL_Asynch_Write_Stream_Result, and ACE_SSL_Asynch_Result classes - to the ace/SSL/SSL_Asynch_Stream.h file so applications can see them. - -USER VISIBLE CHANGES BETWEEN ACE-5.4.10 and ACE-5.5 -==================================================== - -. Added a platform macros option "templates=manual", currently only - applies to AIX 5.3 with XL 7 compiler. It allows the user to tell the - compiler to set -qnotempinc and -qnotemplateregistry and works well - in static builds. - -. ACE and its tests compile error free with GCC 4.1 pre release. - -. ACE_Recursive_Thread_Mutex::get_nesting_level() fixed for 64-bit Windows - XP on amd64/EM64T hardware. - -. Many build-time fixes for Windows Mobile 5 and Windows PocketPC 2003 using - Visual Studio .NET 2005 (VC8). - -. Added support for the --enable-tk-reactor configure option to the - autoconf build infrastructure to build the ACE_TkReactor library. - -USER VISIBLE CHANGES BETWEEN ACE-5.4.9 and ACE-5.4.10 -==================================================== - -. Fixed a bug in ACE_Timer_Heap_T::cancel(). - -. Improved ACE_Time_Value support for boundary conditions. - -. Fixed problems with operator placement delete on certain C++ compilers. - -. Fixed a bug with the ACE_SPIPE_Acceptor on Windows. - -. Correctly set sockaddr_in.sin_len and sockaddr_in6.sin6_len on - platforms that have these fields. - -. Avoided problems with namespace pollution for max() macros. - -. Many fixes for ACE_LACKS* and ACE_HAS* macros for autoconfig. - -USER VISIBLE CHANGES BETWEEN ACE-5.4.8 and ACE-5.4.9 -==================================================== - -. Added dozens of new ACE_LACKS and ACE_HAS defines which are used to - simplify the ACE_OS layer - -. Constructors of ACE_Time_Value have been made explicit to prevent - implicit conversions. - -. Added a shutdown() method to ACE_Barrier. The new method aborts the - wait by all threads. - -. Changed the behavior of ACE_Message_Queue::enqueue_head() and - enqueue_tail(). If the enqueued message block has other blocks - chained to it via its next() pointer, the entire chain of blocks - will be enqueued at once. - -. Improved the support for high-resolution timers with - ACE_Timer_Queue_Adapter. - -. Make it possible to disable file caching in JAWS. - -. Improved ACE_Pipe implementation so that it uses localhost to avoid - firewall problems. - -. Added Unicode support to the Service Configurator. - -USER VISIBLE CHANGES BETWEEN ACE-5.4.7 and ACE-5.4.8 -==================================================== - -. Improved IPv6 support - -. Improved 64bit portability - -. TTY_IO overhaul - - Improved documentation. - - It is now possible to request infinite timeout in portable manner. - This can be achieved by setting negative value to readtimeoutmsec. - - Various bugs fixed and portability issues resolved. - -. Subset ACE for TAO and TAO Services - -. Support for Intel C++ 9.0 on Windows and Linux - -. Support for Microsoft Visual Studio 2005 (aka VC8) for Win32 as well - as the Windows CE platforms Pocket PC 2003 and Windows Mobile 5. - Solution/project files are generated with an appended "_vc8" for - Win32 and "_WinCE" for the CE platforms. See - ACE_wrappers/docs/CE-status.txt for more information. - -. Completed implementation of ACE_Dev_Poll_Reactor using the Linux epoll - facility; tested on Red Hat Enterprise Linux 4. - -. The in-memory size of an ACE_RB_Tree will be smaller due to rearranged - placement of pointers. - -. Added an optimization to CDR stream to ignores alignment when marshaling - data. Use this new ACE_LACKS_CDR_ALIGNMENT compile-time option only - when the ACE_DISABLE_SWAP_ON_READ macro is enabled. This new option - requires ACE CDR engine to do both marshaling and demarshaling, and - when this option is enabled the encoded streams are no longer - compliant with the CORBA CDR specification. - -. Developed Feature Oriented Customizer (FOCUS) tool to enable - specialization of middleware frameworks such as Reactor and Protocol - framework. FOCUS provides an XML based transformation engine, where - the transformations to specialize the components are captured in XML - file and a weaver specializes the code. - -. Added support for unrolling ACE_OS::memcpy copy loop where - applicable to improve performance. Autoconf tests empirically - determine whether loop unrolling is at least 10% better than default - version. - -. Added support for an ACE "versioned" namespace. When enabled, ACE - library sources will be placed within a namespace of the user's - choice or a namespace of the form ACE_5_4_7 by default, where - "5_4_7" is the ACE major, minor and beta versions. The default may - be overridden by defining the ACE_VERSIONED_NAMESPACE_NAME - preprocessor symbol. Enable overall versioned namespace support by - adding "versioned_namespace=1" to your MPC default.features file. - -USER VISIBLE CHANGES BETWEEN ACE-5.4.6 and ACE-5.4.7 -==================================================== - -. Support for shared libraries with VxWorks - -. Support for Solaris 10 on x86 with Sun Studio 10 (C++ 5.7). - -. Extended ACE_OS::event_xxx implementation to support platforms - having either PThread support with Process Shared condition - variables or POSIX semaphores with named (process shared) - semaphore support or using the new FIFO based semaphores. - -. ACE_OS::closesocket() no longer calls ACE_OS::shutdown() on any platform - while closing the socket. It previously called ACE_OS::shutdown() on - HP-UX. Removing this call fixes the fork-and-close programming paradigm - that's common to many networked applications. - -. RMCast - - Support for message fragmentation. This will allow - for messages larger than 64K. - - Support for flow control. - - Timed recv() in RMCast::Socket. - - Per-instance configurable protocol parameters (e.g., message - retention time, NAK timeout, etc). - -USER VISIBLE CHANGES BETWEEN ACE-5.4.5 and ACE-5.4.6 -==================================================== - -. Updated RMCast to include - - Reactor-compatible interface. - - Message unavailability reporting. - - Protocol documentation. - -. Added support for 64bit Visual Age on AIX - -. Improved g++ 4.0 support. A number of RTTI related problems have been - fixed. - -. Smaller footprint. - -. Fixed memory leaks ACE_DLL and ACE_Log_Msg classes. - -. The ACE::ICMP_Socket and ACE::Ping_Socket classes were moved out of - the ACE namespace and "flattened" to ACE_ICMP_Socket and - ACE_Ping_Socket to be consistent with the rest of ACE. - -. ACE_INET_Addr::set_address() - fixed a possible struct member - alignment issue when building an IPv4-mapped IPv6 address. - -. Added a new ACE::wild_match() function to match a string based on - wildcards. - -. Added efficient overloads for string concatenation to the - ACE_String_Base class. - -. Added support for the use of pthread_getschedparam on MacOS X. - -. Fixed an issue with static initialization of TSS related classes on - static builds for Windows. - -USER VISIBLE CHANGES BETWEEN ACE-5.4.4 and ACE-5.4.5 -==================================================== - -. Remove special handling in the Thread Specific Storage(TSS) code - that released the TSS key for ACE_TSS. ACE_TSS has - been changed to explicitly free the TSS key when necessary. - -. On Win32 systems: detect thread termination via a hook in DLLMain - for ACE.dll. This allows cleanup of TSS objects for non-ACE threads - that use ACE functions. The most common case was threads that used - ACE logging. Formerly any TSS objects created by these threads would - be leaked. - -. Added support for GNU G++ 4.0. The x.4.5 beta takes advantage of - g++ 4.0's symbol visibility. This feature is conceptually similar - to MS Windows "__declspec(dllexport)" DLL functionality. Using this - new g++ feature results in substantially improved ACE/TAO/CIAO - shared library binaries. A subset of the improvements include the - following: - - * The number of unnecessarily exported DSO/DLL symbols is - greatly reduced, resulting in faster program start times. - * Smaller footprint. - * Improved performance since run-time indirection of internal - symbols is no longer needed. - - No changes to the ACE/TAO sources were necessary to support this - feature since the required visibility attributes were hidden behind - the various "*_Export" macros (formerly only useful for MS Windows - DLLs) used throughout ACE/TAO. - -. The ACE_Reactor destructor will now call close() on the referenced reactor - implementation. This assures that all handlers are notified before the - ACE_Reactor object that's most likely referenced in these handlers is - invalid. Although this should not be a user-visible change, it did catch - some ACE tests off guard destroying reactor implementations and ACE_Reactor - interfaces in the wrong order, so it may come up in the field as well. - When using dynamically allocated reactor implementations, do not destroy - the implementation object before the ACE_Reactor interface object. Use of - the ACE_Reactor constructor's delete_implementation argument (with a value - of 1) is recommended when dynamically allocating reactor implementations. - -. Improved performance of HTBP by not requiring a lookup of peer hostname. - -. Added new ACE_SizeCDR stream which allows one to calculate size of the - representation without writing anything. - -. Number of improvements in RMCast, reliable multicast implementation. - -USER VISIBLE CHANGES BETWEEN ACE-5.4.3 and ACE-5.4.4 -==================================================== - -. The ace-config script has been replaced by pkg-config metadata files - which are installed in ${prefix}/lib/pkgconfig by the automake build. - -. Remove ACE_OS::gets() implementation. While this ACE implementation - of gets() did not contain the security holes that all standard - gets() implementations have, keeping it around only serves to foster - confusion since (1) some may incorrectly assume that this - ACE-specific gets() implementation has the same holes as standard - ones, and (2) invoking it with a default size argument so that it - looks like a standard gets() call results in behavior that is - different from the standard. Use ACE_OS::fgets() instead. - -. Removed ACE_Unbounded_Set_Ex, this gave the false idea that it had - thread safe iterators. Use ACE_Unbounded_Set instead - -. Improved VxWorks support for static libraries. Shared libraries do cause - several known problems which will be fixed in the x.4.5 release. - -. Removed the usage of the ACE_x_cast macros, we are using the C++ casts - from now on. The ACE_x_cast macros are deprecated and will be removed - after the x.5.1 release - -. Some improvements in autoconf support; better detection of available - OS and compiler features. - -. Fixed bugs in ACE TSS emulation - -USER VISIBLE CHANGES BETWEEN ACE-5.4.2 and ACE-5.4.3 -==================================================== - -. Improved Cygwin 1.5.12 support, 90% of the tests now succeed - -. Improved OpenVMS support. - -. Added ability to use fltk with Cygwin/MinGW - -. Added ACE_INT64 that defines a native 64 bit type. - -. Added 'q' as usable specifier for ACE_Log_Msg to print out int64 bit number. - -. Added better support for Intel C++ compilers. - -. Improved HPUX support. - -. Added a new directory ("ACE_wrappers/protocols/ace") for new protocols - that are not directly components of ACE, but are relate to ACE and - defined a new protocol, HTBP (Hypertext Tunneling, Bidirectional - Protocol) providing ACE_Acceptor/Connector/Stream semantics over a - connection owned by an HTTP proxy. Test cases in - ACE_wrappers/tests/HTBP provide examples of use. - -. Performace enhancement in TP_Reactor's handle_timer_events method [Bug - 1971]. - -. Various changes to permit ACE to execute on HP NonStop platform (e.g - support for its pthreads version). - -. Updated HP NonStop configuration files (config-tandem-nsk). - -. The "ACE" pseudo-namespace is now a true C++ namespace. Transitional - pseudo-namespaces that were only meant to be used internally by ACE, - such as "ACE_Sock_Connect", no longer exist. - -. ACE_CDR::Boolean type is now a true C++ "bool" on all platforms except - MSVC++ 6. We plan to deprecate MSVC++ 6 support sometime after the - x.5 release of ACE+TAO+CIAO, so we recommend you start migrating to a - later version of MSVC++. - -. More GNU g++ 3.4.x fixes. - -. Added ICMP and "ping" socket support. - -. Added mkstemp() emulation. - -. Fixed problem on Linux < 2.5.47 platforms where equality comparison of - two logically equal sockaddr_in structure instances would incorrectly - fail. - -. Support for wide characters has been improved on non-Windows - platforms. - -. A number of Windows CE problems have been fixed. - -. ACE's loading of DLLs (for example, as a result of loading synamic - services) has been changed to use the native OS's facilities for - locating the DLL instead of searching LD_LIBRARY_PATH (or its - equivalent) then loading the DLL using a full pathname. This restores - enforcement of a platform's loading and security policy. To use the - old DLL locating method, add ACE_MUST_HELP_DLOPEN_SEARCH_PATH to your - config.h file before building ACE. - -. A number of errors in the APG example programs have been corrected. - -. Select_Reactor and Priority_Reactor performance improved. [Bug 1890] - -. Wide-char functionality on POSIX (Linux, etc.) - -. TSS memory leak fixes [Bug 1542] - -. Ported to HPUX 11i v2 on Itanium - -. Added code to ACE for platform RedHat AS 3.0 on Opteron. - -. Changed ACE::crc32() family of functions to NOT fold in the length of - the string/buffer/iovec into the CRC. - - -USER VISIBLE CHANGES BETWEEN ACE-5.4.1 and ACE-5.4.2 -==================================================== - -. Support for g++ 3.4.1. - -. All ACE Makefiles, project files, etc, are now generated by OCI's - "MakeProjectCreator" (MPC) tool. Makefiles and project files for - commonly used configurations have been pre-generated and distributed - with the beta(s). Please see: - - $ACE_ROOT/ACE-INSTALL.html - - for information on how to use MPC with ACE. - -. Improved Doxygen documentation. - -. Reduced header file dependencies, which should speedup compilation - and help minimize static footprint. - -. ACE now requires support for the following standard C++ features: - - - "bool" keyword - - - "mutable" keyword - - - "explicit" keyword - - - C++ casts (e.g. static_cast<>, reinterpret_cast<>, dynamic_cast<> - and const_cast<>) - - If you're using a compiler that does NOT support these features - please contact Steve Huston for support. - -. Changed the select()-based reactor implementations to scan for - broken handles to remove based on the registered handles, not on - event handlers. This allows for bad handles to be removed from the - reactor even if the event handler doesn't implement get_handle() the - way we expect. - -. Support for Pthreads native recursive mutexes was added. This - capability is specified to ACE_OS::mutex_init() as an optional - argument, lock_type. To fix confusion from an earlier attempt to add - this functionality, the meaning of the old 'type' argument to - ACE_OS::thread_mutex_init() is changed. It previously combined the - scope and type. Now it is just the type (e.g. recursive), as the - scope is inherent in the method used. For clarification on - ACE_HAS_RECURSIVE_MUTEXES, it means that the platform is capable of - them, not that they always are, as one would expect. However, before - Pthreads had recursion added, it was never optional. Now it is. - -. Initial support for new Linux sys_epoll() interface in - Dev_Poll_Reactor. The obsolete Linux /dev/epoll interface is no - longer supported. - -. Improved Cygwin support. - - Threading works without problems. - - Problems with shared memory, process shared mutexes, multicast and - some other small things still exist. - -. New OpenVMS port. - - This is for the latest version of OpenVMS with all available ECOs - applied. Basic stuff works without problems. Advanced features - still need some work. - -. Usage of ASYS_INLINE is deprecated in ACE. Use ACE_INLINE instead. - -. All inline source files now end in ".inl". The previous ".i" - extension is generally used for preprocessed C sources. - -. Autoconf support has been improved and fixed on a number of - platforms, including the BSD variants (e.g. FreeBSD). It is still - not the preferred way to configure most platforms, but it is ready - for wider testing. Please report any problems found to - ace-bugs@cs.wustl.edu. - -. A number of fixes were made to quiet compile errors and warnings on - 64-bit Windows. - -. For builds on AIX using Visual Age C++, the make rtti option default - was changed to 1, enabling RTTI by default. - -. ACE_Service_Repository::remove() has a new, optional argument that - can receive the service record pointer for the removed service. If - the pointer is returned to the caller, it is not deleted. If the - pointer is not returned to the caller (the default) it is deleted - (this is the historic behavior). - -. The tutorials in ACE_wrappers/docs have been removed. They were not - being maintained and caused confusion in a number of cases. Now that - there are complete examples that match the printed books (C++NPv1, - C++NPv2, APG), the older tutorials are no longer useful. Please see - - $ACE_ROOT/examples/C++NPv1/ - $ACE_ROOT/examples/C++NPv2/ - $ACE_ROOT/examples/APG/ - - for the source code of the examples in those books. - -. ACE_String_Base::fast_clear() is a new method which sets the string - length to 0. Doesn't release string-allocated memory, but if the - memory was externally supplied, it is no longer referenced from the - string object. - -. A true C++ "bool" is now used as the CDR stream boolean type, if - supported by the compiler. - -. Renamed AIX 5L configuration header from config-aix5.1.h to - config-aix-5.x.h. - -. All C++ equality, relational and logical operators now return bool - instead of int, as is the norm for modern C++. - -. Added new ACE_OS::realpath() implementation. Contributed by Olli - Savia - - -USER VISIBLE CHANGES BETWEEN ACE-5.4 and ACE-5.4.1 -==================================================== - -ACE ---- - -. Fixed "make install" support in ACE+autoconf configurations. - -. Fixed autoconf support on Solaris. - -. Corrected invalid `aux' directory (on MS Windows) found in ACE - distribution. - -. ACE/TAO build now without problems with MinGW and all ACE tests run - now without problems - -. Added some more support for the new CBuilderX Preview compiler, this - is not 100% ready yet because the compiler is still a preview and - has its own problems. - -. Added Visual SlickEdit 8.1 MPC template - -. Added workaround for compile problems in Borland Release builds - -. Cygwin 1.5.9 is now supported - -. Tests for IPV6 have been added - -. Implement lstat() so that it'll use stat() on platforms that don't - support lstat(). - -. Problems related to ACE_Event_Handler usage in WFMO_Reactor was - fixed. - -. A wrapper for rmdir () has been added. - -. Threads spawned in thread-per-connection mode never inherited the - priority. This problem was fixed and this fix is consistent with the - C++ NPV* books. - -. Fixed memory leaks with ACE_String_Base::resize () - -. Enable the usage of native recursive mutexes for the implementation - of ACE recursive mutexes on Linux. - -. The ACE Proactor framework can now be enabled for AIX 5.2. Since AIO - functionality is not run-time enabled by default on AIX 5.2, the ACE - Proactor code is not built by default on AIX. To enable it, the - config.h file must contain #define ACE_HAS_AIO_CALLS before - including the config-aix-5.1.h file. - -. The ACE_POSIX_CB_Proactor implementation is now built on all - platforms except LynxOS. - - -USER VISIBLE CHANGES BETWEEN ACE-5.3.6 and ACE-5.4 -================================================== - -ACE: ---- -. Added a new makefile commandline flag, static_link, that can be - used to force static linking when static_libs_only is turned on. It - uses the new STATIC_LINK_FLAG variable and is currently only - implemented for for GNU ld, i.e., it adds the "-static" option to - LDFLAGS. It's turned off by default since using it causes the - footprint to go up by almost 1 MB on Linux, since it links all the - system and compiler .a files, but can be turned on if users - want/need to use it, by enabling both static_libs_only and static_link. - - -. Added macros ACE_USES_GPROF which enables users to use gprof in a - multithreaded environment with ACE libs. - -. Added a new functor template class, ACE_Malloc_Lock_Adapter_T, - that's used by ACE_Malloc_T as a factory for the ACE_LOCK template - parameter, and allows the use of locking strategy classes, like - ACE_Process_Semaphore and ACE_Thread_Semaphore that don't have a - satisfactory ctor taking a single required ACE_TCHAR* parameter, to - be adapted to work with ACE_Malloc_T. - -. The source code examples from "The ACE Programmer's Guide" book by - Huston, Syyid, and Johnston, are now located in - $ACE_ROOT/examples/APG. - -. Support for GNU autoconf is now in ACE. Please see ACE-INSTALL.html - for details. - -. Fixed problems that prevented ACE from being compiled on LynxOS - 4.0.0. - -. Fixed compilation error which prevented ACE from being compiled when - ACE_COMPILE_TIMEPROBES was set to 1. - -. Preliminary support for Tandem NSK has been added. - -. Lots of bug fixes with TLI and XPG5. Please see $ACE_ROOT/ChangeLog - for details. - -. Fixed ACE_OS::event_timedwait() and ACE_OS::event_wait() so that - they use a while loop around the ACE_OS::cond_[timed]wait() calls to - avoid problems with spurious wakeups, etc. - -. ACE's wrapper around getipnodebyname() and getipnodebyaddr () has - been made go through the IPv4-only case on ACE_WIN32. Since Windows - IPv6 implementation doesn't offer support (at thistime) for - getipnodebyname() the code has been changed to use the IPV4 part of - the code. - -. Install with Borland C++ of ACE library fixed - -ACEXML: -------- - -. Fixed memory leak in ACEXML parser. - -. Fixed implementations of rewind() in all the CharStreams. They were - broken previously. - -. Fixed bugs in the parser associated with incorrect handling of PE - References for keywords. diff --git a/deps/acelite/PROBLEM-REPORT-FORM b/deps/acelite/PROBLEM-REPORT-FORM deleted file mode 100644 index 7a6ba05c9..000000000 --- a/deps/acelite/PROBLEM-REPORT-FORM +++ /dev/null @@ -1,87 +0,0 @@ -[Please use the PRF form below to submit bug reports, problem reports, - etc., to the ACE developers and interested users. Send it to - ace-bugs@list.isis.vanderbilt.edu, you must be subscribed to the list - in order to be able to post to it. If you are using OCI, MicroFocus, or - Riverace's versions of ACE do not send bugs to this mailing list, but - instead contact those companies for support. Please also send your - PRF as plain ASCII text, _not_ uuencoded or as an attachment. - - We prefer that all bug reports be submitted through github issues. - See https://github.com/DOCGroup/ACE_TAO/issues for more information - about how to do this. If you are unsure as to whether your problem - is a real bug or not then please submit your question to the mailing - list using the following form. Not using the problem report form - will make it harder or impossible to identify the problem, and in - many cases we will be unable to help at all. Also please try to - browse the existing github isssues and the ChangeLog files to find - out if your problem has been solved in a more recent version of ACE. - - To subscribe to the list see - https://www.dre.vanderbilt.edu/~schmidt/ACE-mail.html - - Replace/remove all the explanatory text in brackets before mailing. - - Please send this form as ASCII text only. Do _not_ send it as an - attachment, or as tar'ed, compressed and/or uuencoded text. And - limit line lengths to less than 80 characters. - - PLEASE make your Subject: line as descriptive as possible. - Subjects like "ACE bug" or "bug report" are not helpful! - Also, do _not_ include the word "help" in the Subject!] - - When including your config.h and platform_macros.GNU files as requested - below, only include the contents if you use the recommended method of - including the platform-specific file in your file. If you use a link - to the platform-specific file, simply state which one - DO NOT - include an entire platform-specific configuration file in the form. - -8<----------8<----------8<----------8<----------8<----------8<----------8<---- - -To: ace-bugs@list.isis.vanderbilt.edu -Subject: [area]: [synopsis] - - ACE VERSION: 6.5.10 - - HOST MACHINE and OPERATING SYSTEM: - If on Windows based OS's, which version of WINSOCK do you - use?: - - TARGET MACHINE and OPERATING SYSTEM, if different from HOST: - COMPILER NAME AND VERSION (AND PATCHLEVEL): - - THE $ACE_ROOT/ace/config.h FILE [if you use a link to a platform- - specific file, simply state which one]: - - THE $ACE_ROOT/include/makeinclude/platform_macros.GNU FILE [if you - use a link to a platform-specific file, simply state which one - (unless this isn't used in this case, e.g., with Microsoft Visual - C++)]: - - CONTENTS OF $ACE_ROOT/bin/MakeProjectCreator/config/default.features - (used by MPC when you generate your own makefiles): - - AREA/CLASS/EXAMPLE AFFECTED: -[What example failed? What module failed to compile?] - - DOES THE PROBLEM AFFECT: - COMPILATION? - LINKING? - On Unix systems, did you run make realclean first? - EXECUTION? - OTHER (please specify)? -[Please indicate whether ACE, your application, or both are affected.] - - SYNOPSIS: -[Brief description of the problem] - - DESCRIPTION: -[Detailed description of problem. Don't just say " -doesn't work, here's a fix," explain what your program does -to get to the state. ] - - REPEAT BY: -[What you did to get the error; include test program or session -transcript if at all possible. ] - - SAMPLE FIX/WORKAROUND: -[If available ] diff --git a/deps/acelite/README b/deps/acelite/README deleted file mode 100644 index e00ba30f2..000000000 --- a/deps/acelite/README +++ /dev/null @@ -1,216 +0,0 @@ -This document is also available at the following URL: - -https://www.dre.vanderbilt.edu/~schmidt/ACE.html - -All software and documentation is available via both anonymous ftp and -http. - -THE ADAPTIVE COMMUNICATION ENVIRONMENT (ACE) - -An Object-Oriented Network Programming Toolkit - ----------------------------------------- - -Overview of ACE - -The ADAPTIVE Communication Environment (ACE) is an object-oriented -(OO) toolkit that implements fundamental design patterns for -communication software. ACE provides a rich set of reusable C++ -wrappers and frameworks that perform common communication software -tasks across a range of OS platforms, including Win32/Win64, most -versions of UNIX (e.g., SunOS, HP-UX , AIX, Linux, NetBSD, and FreeBSD), -real-time operating systems (e.g., VxWorks, Chorus, LynxOS, and QNX), -OpenVMS, and MVS OpenEdition. A single source tree is used for all -these platforms and porting ACE to other platforms is relatively easy. - -The communication software components provided by ACE include event -demultiplexing and event handler dispatching, service initialization, -interprocess communication, shared memory management, message routing, -dynamic (re)configuration of distributed services, multi-threading, -and concurrency control. There are both C++ and Java versions of ACE -available. - -ACE is targeted for developers of high-performance and real-time -communication services and applications on UNIX, POSIX, and Win32 -platforms. ACE simplifies the development of OO network applications -and services that utilize interprocess communication, event -demultiplexing, explicit dynamic linking, and concurrency. ACE -automates system configuration and reconfiguration by dynamically -linking services into applications at run-time and executing these -services in one or more processes or threads. - -ACE is currently used in commercial projects and products by dozens of -companies including Ericsson, Bellcore, Siemens, Motorola, Kodak, -Boeing, Lucent, DEC, Lockheed Martin, and SAIC. Commercial support -for ACE is available from several companies as listed at -http://www.dre.vanderbilt.edu/~schmidt/commercial-support.html - ----------------------------------------- - -C++ Wrappers for OS Interfaces - -The lower-level portions of ACE provide a set of portable and -type-secure C++ wrappers that encapsulate the following C language OS -interfaces: - -. IPC mechanisms - -- e.g., Internet- and UNIX-domain sockets, TLI, Named - Pipes (for UNIX and Win32) and STREAM pipes; - -. Event demultiplexing - -- e.g., select(), poll(), and Win32 - WaitForMultipleObjects and I/O completion ports; - -. Multi-threading and synchronization - -- e.g., Solaris threads, POSIX Pthreads, and Win32 - threads; - -. Explicit dynamic linking - -- e.g., dlopen/dlsym on UNIX and LoadLibrary/GetProc - on Win32; - -. Memory-mapped files and shared memory management - -- e.g., BSD mmap(), SYSV shared memory, and Win32 - shared memory; - -. System V IPC - -- e.g., shared memory, semaphores, message queues. - -The OS Adaptation Layer shields the upper levels of ACE from platform -dependencies associated with the underlying OS interfaces. - ----------------------------------------- - -Frameworks and Class Categories - -ACE also contains a higher-level network programming framework that -integrates and enhances the lower-level C++ wrappers. This framework -supports the dynamic configuration of concurrent distributed services -into applications. The framework portion of ACE contains the -following class categories: - -. The Reactor - -- Supports both Reactive and Proactive I/O; - -. The Service Configurator - -- Support dynamic (re)configuration of objects; - -. The ADAPTIVE Service Executive - -- A user-level implementation of System V STREAMS, - that supports modular integration of - hierarchically-related communication services; - -. Concurrency - -- Various types of higher-level concurrency - control and synchronization patterns (such as - Polymorphic Futures and Active Objects); - -. Shared Malloc - -- Components for managing dynamically allocation - of shared and local memory; - ----------------------------------------- - -Distributed Services and Components - -Finally, ACE provides a standard library of distributed services that -are packaged as components. These service components play two roles -in ACE: - -1. They provide reusable components for common distributed - system tasks such as logging, naming, locking, and time - synchronization. - -2. They illustrate how to utilize ACE features such as the - Reactor, Service Configurator, Service Initialization, - Concurrency, and IPC components. - ----------------------------------------- - -Middleware Applications - -ACE has been used in research and development projects at many -universities and companies. For instance, it has been used to build -avionics systems at Boeing, telecommunication systems at Bellcore, -Ericsson, Motorola, and Lucent; medical imaging systems at Siemens and -Kodak; and many academic research projects. Two example middleware -applications provided with the ACE release include: - -1. The ACE ORB (TAO) -- TAO is a real-time implementation of - CORBA built using the framework components and patterns - provided by ACE. - -2. JAWS -- JAWS is a high-performance, adaptive Web server - built using the components in ACE. - ----------------------------------------- - -OBTAINING ACE - -ACE may be obtained electronically from -https://download.dre.vanderbilt.edu. This release contains the source -code, test drivers, and example applications (including JAWS) for C++ -wrapper libraries and the higher-level ACE network programming -framework developed as part of the ADAPTIVE project at the University -of California, Irvine, Washington University, St. Louis, and -Vanderbilt University. - -You can get The ACE ORB (TAO) in a companion release at the same URL. - ----------------------------------------- - -ACE DOCUMENTATION AND TUTORIALS - -Many of the C++ wrappers and higher-level components have been -described in issues of the C++ Report, as well as in proceedings of -many journals, conferences, and workshops. - -A collection of white papers and tutorial handouts are included at - -http://www.dre.vanderbilt.edu/~schmidt/ACE-papers.html - -This page contains PDF versions of various papers that describe -different aspects of ACE. - -This material is also available available via the WWW at URL: - -http://www.dre.vanderbilt.edu/~schmidt/ACE.html - ----------------------------------------- - -ACE MAILING LIST AND NEWSGROUP - -A mailing list, ace-users@list.isis.vanderbilt.edu, is available for -discussing bug fixes, enhancements, and porting issues regarding ACE. -Please send mail to me at the -ace-users-request@list.isis.vanderbilt.edu if you'd like to join the -mailing list. Please see -http://www.dre.vanderbilt.edu/~schmidt/ACE-mail.html for details on -how to subscribe to the mailing list. - ----------------------------------------- - -BUILDING AND INSTALLING ACE - -Please refer to the $ACE_ROOT/ACE-INSTALL.html file for -information on how to build and test the ACE wrappers. The -BIBLIOGRAPHY file contains information on where to obtain articles -that describe the ACE wrappers and the ADAPTIVE system in more detail. - -The current release has been tested extensively, but if you find any -bugs, please report them to the ACE mailing list -ace-users@list.isis.vanderbilt.edu using the -$ACE_ROOT/PROBLEM-REPORT-FORM. Please use the same form to submit -questions, comments, etc. To ensure that you see responses, please do -one of the following: - -1) Subscribe to the ace-users mail list, by sending email with - contents "subscribe ace-users" to - ace-users-request@list.isis.vanderbilt.edu. - ----------------------------------------- - -ACKNOWLEDGEMENTS - -Please see the file `$ACE_ROOT/THANKS' for a list of the thousands of -people who've contributed to ACE and TAO over the years. diff --git a/deps/acelite/THANKS b/deps/acelite/THANKS deleted file mode 100644 index 10b223188..000000000 --- a/deps/acelite/THANKS +++ /dev/null @@ -1,2425 +0,0 @@ -ACKNOWLEDGEMENTS - -ACE, TAO, CIAO, and DAnCE have been deeply influenced and improved by the -following members of my research group at Washington University in St. Louis, -the University of California at Irvine, and Vanderbilt University in Nashville. - -Everett Anderson -Alexander Babu Arulanthu -Shawn Atkins -Jaiganesh Balasubramanian -Krishnakumar Balasubramanian -Matt Braun -Darrell Brunsch -Dante J. Cannarozzi -Sharath R. Cholleti -Chris Cleeland -Angelo Corsaro -Gan Deng -Mayur Deshpande -Eric Ding -George Edwards -Sergio Flores-Gaitan -Chris Gill -Andrew G. Gilpin -Aniruddha Gokhale -Priyanka Gontla -Pradeep Gore -Matthew P. Hampton -Tim Harrison -John Heitmann -James Hill -Shawn Hannan -Don Hinton -Joe Hoffert -James Hu -Huang-Ming Huang -Frank A. Hunleth -Prashant Jain -Shanshan Jiang -Vishal Kachroo -Michael Kircher -Boris Kolpackov -Arvind S. Krishna -Yamuna Krishnamurthy -Fred Kuhns -David Levine -Tao Lu -Mike Moran -Sumedh Mungee -Balachandran Natarajan -Will Otte -Kirthika Parameswaran -Krishnakumar Pathayapura -Stoyan Paunov -Carlos O'Ryan -Ossama Othman -Jeff Parsons -Irfan Pyarali -Nilabja Roy -Lucas Seibert -Diego Sevilla Ruiz -Nishanth Shankaran -Marina Spivak -Venkita Subramonian -Nagarajan Surendran -Cassia Tatibana -Sumant Tambe -Gabriele Trombetti -Emre Turkay -Nanbor Wang -Seth Widoff -Jules White -Friedhelm Wolf -Torben Worm -Ming Xiong - -I would also like to thank all the following people who have also -contributed to ACE, TAO, CIAO, and DAnCE over the years: - -Paul Stephenson -Olaf Kruger -Ed Brown -Lee Baker -Alex Ranous -Mark Patton -Steffen Winther Sorensen -Troy Warner -Stacy Mahlon -Charles Eads -Mark Frutig -Todd Hoff -George -Brad Needham -Leslee Xu -Detlef Becker -Bruce Worden -Chris Tarr -Bill Sears -Greg Lavender -Steve Warwick -Mats Sundvall -Andreas Ueltschi -Nigel Hooke -Medhi Tabatabai -Stuart Powell -Bin Mu -Andrew McGowan -Ken Konecki -John P. Hearn -Giang Hoang Nguyen -Carlos Garcia Braschi -Jam Hamidi -Eric Vaughan -Karlheinz Dorn -Gerhard Lenzer -Steve Ritter -Chandra Venkatapathy -Matt Stevens -Bob Vistica -David Trumble -George Reynolds -Hans Rohnert -Alex V. Maclinovsky -Todd Blanchard -Rob Clairmont -Christian Millour -Neil B. Cohen -Dieter Quehl -Reginald S. Perry -James Morris -Mark Seaborn -Phil Brooks -E. Jason Scheck -Daniel Proulx -Bill Tang -John Huchinson -Jack Erickson -Byron Walton -Bill Lear -Mark Zusman -Aurelio Nocerino -Walt Akers -Greg Baker -Alexandre Karev -Pramod Kumar Singh -Bryon Rigg -Brad Brown -Patty Genualdi -Eshel Liran -Mick Adams -Chris Eich -Mike Flinn -Audun Tornquist -Sandeep Joshi -Bernd Hofner -Craig Perras -Kirk Sinnard -Matthew Newhook -Gerolf Wendland -Phil Mesnier -Ross Dargahi -Richard Orr -Rich Ryan -Jan Rychter -Tom Marrs <0002104588 at mcimail dot com> -Bob Olson -Jean-Francois Ripouteau -Ajit Sagar -Ashish Singhai -David Sames -Gonzalo Diethelm -Raj -Darrin Edelman -Steve Weismuller -Eric C. Newton -Andres Kruse -Ramesh Nagabushnam -Antonio Tortorici -Nigel Lowe -Tom Leith -Michael Fortinsky -Marco Sommerau -Gary Salsbery -Eric Beser -Alfred Keller -John Lu -James Mansion -Jesper S. M|ller -Chris Lahey -Michael R"uger -Istvan Buki -Greg Wilson -Garrett Conaty -Brad Flood -Marius Kjeldahl -Steve Huston -Eugene K. Plaude -Joseph DeAngelis -Kim Gillies -Luca Priorelli -Alan Stewart -Hani Yakan -William L. Gerecke -Craig Johnston -Pierre-Yves Duval -Rochi Febo Dommarco -Jonathan Biggar -Scott Shupe -Chuck Gehr -Avi Nash -Padhu Ramalingam -Jay Denkberg -Ayman Farahat -Tilo Christ -rev -Hamutal Yanay -Vital Aza -Alex Villazon -David Artus -Todd Barkalow -Alexander Smundak -Thilo Kielmann -Matthias Kerkhoff -Fred LaBar -Hanan Herzog -Eric Parker -James Michael Dwyer -Arun Katkere -Bob Dunmire -Sandro Doro -Robert Lyng -Phil Logan -John Cosby -Wayne Vucenic -Harry Gunnarsson -James CE Johnson -Samuel_Bercovici -Per Andersson -Anthony McConnell -Mark Rabotnikov -John Bossom -Rino Simioni -Slawomir Kuzniar -Rob Jordan -Michael Maxie -John Cosby -Nigel Owen -Jorn Jensen -Paul Roman -Dave Mayerhoefer -Bert Craytor -Joey Zhu -Arthur J. Lewis -Michael R. MacFaden -Paul Han -Jeff Morgan -Arturo Montes -Elliot Lau -Mark Wright -Michael Newton -Kumar Neelakantan -Scott Halstead -Jean-Marc Strauss -Adam Porter -Hakan Kallberg -Eric Dean Russell -Daniel Montalibet -Norbert Rapp -Ganesh Pai -Berni Merkle -Tom Wright -Torbjorn Lindgren -Mike Bernat -Brian Mendel -Jeremy Buch -Kevin Boyle -Kevin Martindale -Luis Lopes -Adrian Salt -Hongbo Xu -Michael Hartman -Tom Dobridge -Rich Christy -Satoshi Ueno -Eugene R. Somdahl -Robert Head -Ivan Murphy -Jan Perman -Shankar Krishnamoorthy -Reza Roodsari -Jim Crossley -Johannes Gutleber -Yigong Liu -Erik Urdang -Mike Schweiger -Anthony Mutiso -Jeff R. Hayes -David Brackman -Dave Moore -Joseph Cross -Cherif Sleiman -Stefan Ericsson -Thanh Ma -Oleg Krivosheev -Stephen Coy -Bob Laferriere -Satheesh Kumar MG -Karen Amestoy -Jeff Richard -Samuel Melamed -Vladimir Schipunov -Felix Popp -Billy Quinn -Michael McKnight -Huiying Shen -Alex Chan -Aaron Valdivia -Edan Ayal -Jeffrey Peterson -Neil Lavelle -Steven Wohlever -Manojkumar Acharya -Evgeny Beskrovny -Kirill Rybaltchenko -Laura Paterno -Ben Eng -Mike Kamrad -Marios Zikos -Mark L Boriack -Mark Hyett -Valik Solrzano Barboza -John Connett -Tom Arbuckle -Stephen Henry -Dani Flexer -Michael Hoffman -John Lindal -Dustin Laurence -Ernie Makris -Timothy A. Brown -Pat McNerthney -Lori Anderson -Erik Margraf -Bryan Doerr -Adam Miller -Thomas Jordan -Keith Nicewarner -Frederic Andres -Achint Sandhu -Mitch Kuninsky -Alex Chan -Jeff Hellzen -Thomas Venturella -Philippe O'Reilly -Stan Leeson -Richard Keizer -Edgar Villanueva -Oliver Kellogg -Dave Meyer -Thomas Hampson -Jay Kistler -Scott Snyder -Mark Evans -Todd Pack -Mark Maris -Jason Katz -Jim Penny -Chris Ryan -J dot Russell Noseworthy -Carol Sanders -Jerry Bickle -Paul von Behren -Sudish Joseph -Loren Rittle -Alexander Ovsiankin -Ravi Nagabhyru -Tom Brusehaver -Dave Tallman -Monish Rajpal -Garry Brother -Andreas Schuelke -Ganapathi -James Garrison -Brad Walton -Paul Motuzenko -Kurt Sussman -Rob Thornton -Chanaka Liyanaarachchi -Saneyasu -Steve Kay -Greg White -Ki-hyun Yoon -Umar Syyid -Bill Fulton -Amancio Hasty -Zoran Ivanovic -Sree Oggu -James Risinger -Leo Modica -Bob Scott -Mark Kettner -Kent Watsen -Chris Healey -Philippe Klein -William S. Lear -John Geiss -Ernesto Guisado -Stuart Myles -Lothar Werzinger -Andrew Harbick -Pavel Motuzenko -Ross J. Lillie -Sam Hauer -Frank J. Hodum -David Miron -Anton van Straaten -Joe Covalesky -Bill Backstrom -Jeff Franks -John Mulhern <9107 at mn3 dot lawson dot lawson dot com> -Johan Lundin -Eric Powers -Gabriel Lima -Doug Anderson -Hongyin Quan -Maximilian Hoferer -Kevin Stanley -Jeff Greif -Jeff McDaniel -Andreas Geisler -Bob McWhirter -Daniel Winder -Zheng Han -Christa Schwanninger -Byron Harris -Barney Dalton -Peter Gorgia -Dirk Broer -Joseph E. LaPrade -Goran Lowkrantz -Susan Liebeskind -Dana Hackman -Margherita Vittone Wiersma -Priya Narasimhan -Jeff Hopper -Mats Nilsson -Dongwook Kim -Don Davis -Alberto Villarica -XuYifeng -Tom Shields -Krishna Padmasola -Andre Folkers -Paul Sexton -Marc Lehmann -Anne Blankert -Raja Ati -Clinton Carr -Peter Liqun Na -Frank Adcock -Xu Yifeng -Valery Arkhangorodsky -Alan Scheinine -Andrew G. Harvey -Dann Corbit -James -Jason Milley -Ulf Jaehrig -Peter Nordlund -Mark Weel -Tres Seaver -Erik Koerber -Eric R. Medley -David O'Farrell -Amir Bahmanyari -Ian Wright -David Janello -Rich Wellner -Fernando D. Mato Mira -Jonathan Reis -Seung-Lee Hoon -Russell L. Carter -Bill Hall -Brian Gilstrap -Balaji Srinivasan -Anders W. Tell -Larry Lachman -Terry Rosenbaum -Rainer Blome -Kirk Ellett -Sunil Kumar -T Stach -Ron Barack -Daniel Nieten -Paul K. Fisher -Jim Buck -Olivier Lau -Achim Stindt -Fredrik Lindahl -Joseph Weihs -Serge Kolgan -James Megquier -Martin Krumpolec -Michael Thomas -Vicentini Emanuele -Bob Price -Ramiro Penataro Blanco -Sigg Pascal -Ivan Leong -Virginie Amar -Tom Ziomek -Hamish Friedlander -Mark De Jong -Knut Johannessen -Leif Jakobsmeier -Jon Lindgren -Steve Vinoski -Christian Mueffling -Victor Yu -Jeff Donner -Joe Loyall -Stanislav Meduna -Christian Korn -Ron Barack -Steve Totten -Faron Dutton -Gary York -Patty Hair -Ivan Pascal -William A. Hoffman -Mark Lucovsky -Greg Holtmeyer -Jody Hagins -Patrice Bensoussan -Keith Brown -Barry Hoggard -Peter J. Mason -Jerry D. De Master -Greg Gallant -wym -Karel Zuiderveld -Mike Goldman -Peter Gross -Greg Ross -Stanford S. Guillory -Peter Weat -Magnus Karlsson -Andreas Tobler -John Aughey -Knut-Havard Aksnes -Eric Mitchell -Tommy Andreasen -Slava Galperin -Jeff Olszewski -Sudhanshu Garg -Mike Preradovic -Greg Harrison -Sangwoo Jin -Jacques Salerian -Steve Coleman -Diethard Ohrt -Jacob Jones -Phil Ruelle -Sush Bankapura -Eric Covington -Darren Whobrey -Mason Taube -Rod Joseph -Hans Horsmann -Kevin Royalty -Souhad Mcheik -Mark Little -Tim Stack -Marc Engel -Uma Markandu -Henrik Nordberg -Tad Jarosinski -Andy Marchewka -Neal Norwitz -Frederic Maria -David Hooker -Christian Destor -Andrew Hobson -Andre Folkers -Torsten Kuepper -Hao Ruan -Alexander Davidovich -Cristian Ferretti -N Becker -Yaolong Lan -Elias Sreih -Liang Chen -Mark Laffoon -Ti Z -Brian Dance -Alexey Gadzhiev -Francois Bernier -Bill Rizzi -Peter Windle -Jaepil Kim -Dmitry Goldshtain -Carl Grinstead -Henric Jungheim -Michael Preobrazhensky -Gregory D. Fee -Roland Gigler -Frank Buschmann -Eric Eide -Don Busch -Thomas Lockhart -David Hauck -Keith Rohrer -Tim Rose -Sam Rhine -Chris Schleicher -Margaret Reitz -Thomas Mehrkam -Erik Ivanenko -Sarmeesha Reddy -Steven Tine -Dave Steele -Simeon Simeonov -David H. Whittington -Ian MacDonald -Hans Ridder -Todd Mullanix -Hai Vu -Paul Francis -Kristopher Johnson -Dave Butenhof -Dominic Williams -Srikumar Kareti -Ian Pepper -Kevin Lyda -James D. Rucker -Brian Wallis -Sandeep Goyal -English Malc -Frank O'Dwyer -Long Hoang -Steven D. Chen -Alain Magloire -Jim Rogers -Nick Sawadsky -David Brownell -Richard Stallman -Casey Lucas -Brian C. Olson -Joseph A. Condlin -Serge Du -Mike Mazurek -Christian Schuderer -John R. Taylor -Bill Tovrea -Wallace Owen -Vyacheslav A. Batenin -Edwin D. Windes -Christopher Kohlhoff -Andreas Terstegge -Stefaan Kiebooms -Keith Nichol -Rebecca Sanford -Ram Vishnuvajjala -Tom Bradley -Shaun Ohagan -Dale Wood -Robert Flanders -Gul Onural -Stephen E Blake -Eric S Rosenthal -Sridevi Subramanian -Bruce Trask -Jake Hamby -Rick Weisner -Dennis C. De Mars -V dot Lakshmanan -Hata Yoshiaki -Vidya Narayanan -Sean Landis -Youzhong Liu -John Weald -Gilbert Roulot -Gildo Medeiros Junior -Brian Peterson -Fabrice Podlyski -Darren DeRidder -John Tucker -Oleg Orlov -Timothy Canham -Randy Heiland -Joyce Fu -Surender Kumar -Pradeep Avasthi -Guicheney Christophe -Madhu Konety -Isaac Stoddard -Alvarez -Peter Brandstrom -Eugene Surovegin -Thaddeus Olczyk -John Chludzinski -Pedro Alves Ferreira -Bruce Edge -Dan Butler -Ron MacKenzie -Craig Rodrigues -Phil Y. Wang -David Brock -John Morey -Dwayne Burns -Denis Ouellet -Stefan Ullrich -Brian Raven -Gheorghe Aprotosoaie -Carsten Zerbst -Paul Calabrese -Stephane Chatre -James Whitledge -Erik Johannes -Alex Hornby -Riaz Syed -Clarence M. Weaver -Roger Egbers -Ralf Kluthe -Ruud Diterwich -Bill Nesbitt -Will Skunk -David Digby -Timothy Schimke -Jim Robinson -Peter Mueller -Raghu Nambiath -Mike Gingell -David McCann -Ruediger Franke -Brian Jones -Michael Garvin -Mike Vitalo -Kirk Davies -Arno Pernozzoli -Trey Grubbs -Matthias Schumann -John Gathright -Alexander Villatora -Hoang Duong -Michael Roth -Craig Anderson -Mitsuhiko Hara -Weihai Yu -Tal Lev-Ami -Chris Zimman -Rick Wesson -Sridhara Rao Dasu -Walter Welzel -Anthony Shipman -Tobin Bergen-Hill -Toshio Hori -John Mink -Duane Binder -Randall Sharo -Dave Madden -Cliff_H_Campbell -Narendra Ravi -Krishnakumar B. -David Sunwall -Brian Wright -Yosi Sarusi -Robert Shewan -Skye Sweeney -Lars Immisch -Stefan Wendt -Herbert -Clarence Bishop -Giga Giguashvili -Philipp Slusallek -Matthew Davis -Janusz Stopa -Rusty Conover -Phillippe Merle -Mark Winrock -Boris Kaminer -Martin Botzler -Lorin Hochstein -Wenli Bai -Harry Forry -Jose Rubio -Joerg Pommnitz -Mogens Hansen -Shafiek Savahl -Pierre Grondin -John Masiyowski -Uwe Landrock -Klaus Banzer -Probal Bhattacharjya -Dmitri Katchalov -Alok Gupta -Chien Yueh -John K. Black -Kamen Penev -Gregory Yarmit -Jarek Tomaszewski -Siegurd Weber -Fabrizio Giannotti -Harald Finster -Fritz Bosch -Charles Frasch -Chris Hafey -Rick Hess -David Dunn -Jaymes Galvin -Marat -Sergey Nemanov -Vladimir Kondratiev -John Glynn -Raymond Wiker -Michael Pitman -Joseph Jefferson -Engelbert Staller -George Ball -Dennis Noll -Ronald Fischer -Marvin Allen Wolfthal -Dan Gilboa -Sean Boudreau -Shalini Yajnik -Matt Thompson -Peter C Chien -Bruce Alderson -Christoph Poggemann -Travis Shirk -Alain Sauron -David Delano -Boris Sukholitko -Brian Mason -Thomas Groth -Damien Dufour -Paulo Breda Vieira -Samuel Stickland -Bryan Van de Ven -Greg Siebers -Rob Gabbot -Paul Carreiro -Jovan Kilibarda -Derek Dominish -Devesh Kothari -Stephen Moon -Hani Mawlawi -Benedikt Eric Heinen -Jason Topaz -Alexander Dergatch -Airat A. Sadreev -Klaus Hofmann -Miroslav Koncar -Extern Chatterji -Zach Frey -Ruibiao Qiu -Marcelo Matus -R Seshardi -Stephan Kulow -Alexander Belopolsky -Ben Bourner -Lalitha Chinthamani -Thomas Huang -Sankaranarayanan K. V -Ephraim Vider -Reid Spencer -Kevin Dalley -Jan Nielsen -Jochen Linkohr -Mirko Brandner -Yuval Yosef -Chad Elliott -David X. Callaway -Soren Ilsoe -Eric Hopper -Martin Johnson -Pierre Oberson -Chris Uzdavinis -Ishay Green -Andrey Nechypurenko -Charlie Duke -Jonathan Luellen -Andrew Psaltis -Erik Jones -Ted Burghart -Mike Winter -Judy Ward -Ken Block -Jamshid Afshar -Jerry Jiang -Rob Ruff -Hugh Arnold -Hessel Idzenga -Mark C. Barnes -Suresh Kannan -Alex Scholte -Greg Jansen -Raj Narayanaswamy -Iain Melville -Daniel Lang
-Chris Leishman -Klemen Zagar -Rick Ohnemus -Adamo, Vince -Defang Zhou -Dave Zumbro -Ted Nolan -Jianfei Xu -Alvin C. Shih -J dot Scott Evans -Alex Luk -Kenneth Osenbroch -Jason Czavislak -Alex Chachanashvili -Gilbert Grosdidier -James Briggs -Herbert Wang -Anders Olsson -Sergey Gnilitsky -David Wicks -Girish Birajdar -Hajdukiewicz Markus -Gerwin Robert -Alia Atlas -David Hall -Todd Gruhn -John Hickin -Alex Brown -Rich Seibel -Jim Scheller -Bob Bouterse -Sandeep Adwankar -W Craig Trader -Bruce McIntosh -Natarajan Kalpathy -David O'Farrell -Bob Bouterse -Malcolm Spence -Dong-Yueh Liu -Craig Ball -Norbert Krain -Adrian Miranda -Cody Dean -Hans Scharkowitz -Charles Meier -Tim Sim -Shalabh Bhatnagar -Charles Scott -Espen Harlinn -mulder -Richard L. Johnson -Tam Nguyen -Jeff Graham -Ralph Loader -Ji Wuliu -Wada Hiroshi -Sal Amander -Torsten Pfuetzenreuter -John M. Mills -David McWeeny -Florian Lackerbauer -Manuel Benche -Steve Luoma -Roger Tragin -Alex Bangs -Yangfen Qiu -Johnny Chen -John Foresteire -Larry Peacock -Francisco Bravo -Antti Valtokari -John Smyder -Mathew Samuel -Conrad Hughes -John Rodgers -Charles Taurines -James Lacey -Nick Pratt -Xiaojun Wu -George Lafortune -Aoxiang Xu -Dima Skvortsov -Moore Y. Cao -Wai Keung Fung -Michael Laing -Benoit Viaud -Ken Weinert -Ferran Boladeres Salvad -Steve Vranyes -Jim Melton -Ron Klein -Anuj Singhal -Henrik Kai -Dominic Hughes -Lior Shalev -Charlie Duke -William Horn -Greg Hall -Aviad Eden -Vianney Lecroart -Russell Mora -Samir Shaikh -Eric Yee -Matt Emerson -Yiu L. Lee -Pedro Brandao -Hakon Innerdal -Sami Aario -Ingo Dahm -Vijay Aswadhati -Xiaowen Wang - -Warren Miller -Youngkwan Cho -Dorr H. Clark -Dave McNeely -Eric Malenfant -Roland Fischer -Alexander Libman -Roger Larsson -Martin Stack -Michael Ravits -Derek Viljoen -Hamed Azizadah -Keo Kelly -Joachim Achtzehnter -Tomer Amiaz -Sergey Osokin -Nick Logvinov -Viatcheslav Batenine -Shashi Bhushan -Javier Corrales -J dot Randy Pitz -Richard Reitmeyer -Xavier Montet -Letha Etzkorn -James Dabbs -Matej Sekoranja -Mattias Eriksson -Nicoletta Viale -George Reid -Kim Lester -Wilson Chan -William Rucklidge -Victor Krebss -Chander P. Thareja -John Mills -Haifeng Lee -Hans Utz -Askok Kumar Kalanithi -Chris Able -John Hiltenbrand -Steve Hespelt -Peter Fischer -Madhu Ramachandran -Caleb Epstein -Bruno Marconi -Ken Childress -Michael Kramer -Johnny Willemsen -Jonathan Astle -Javier Lopez Sanchez -Nir Drang -Albert Wijnja -Marcel Van Der Weert -Mervyn Quah -Giovanni Zito -Matthew Adams -Sameer Schabungbam -Jeff Butler -Roland R�denauer -John Buckman -Guy Rosen - -Bennett R. Stabile -Paul Caffrey -Low Aik long -Michael Rinne -Jaffar Shaikh -Roger Beck -Trueman Bill -Harold Bien -Mateu Batle -Philip Miller -Base V Paul -Evghenii Filippov -Mike Curtis -Jessie Ragsdale -Shourya Sarcar -Eric Crampton -Sandip Patel -ChenXu -Vsevolod Novikov -Brendan Corcoran -Steve Sivier -Rick Schneeman -Klaus H. Wolf -Jean-Christophe Dubois -Michael Hampel -Wei Zheng -Bernd Annamaier -Joachim Tremouroux -Momchil Velikov -Munagala Ramanath -Kevin Marshall -David Channon -Andy Guy -Oscar Rodriquez -Jonathan Cano -Alain Decamps -Paul Rubel -Jon Loeliger -Ricardo Chan -Sarabjeet Duhra -Michael Rushton -Arno Pernozzoli -Calum Mitchell -Jerry Odenwelder -Kent Stewart -Alexander Kogan -Michael Lindner -Arnaud Compan -Michael Searles -Bogdan Jeram -Sebastian Schubert -Li Zhou -Shivakumar Patil -Steve Olson -Allen Broadman -Yuriy Zaporozhets -Joe Guan -Attilio Dona -McGanahan Skjellifetti -Matthias Wittig -David Allen -Edwin McKay -Scott Bolin -Mike Anderson -David Singer -Nick Lin -Ron Hashimshony -Max Khon -Jonas Nordin -Jonathan Stockdale -Jean-Francois Daune -Wei Chiang -Rick Stille -Kirill Kuolechov -Edwin Wrench -Yung Trinh -Richard Eperjesi -Ben Strong -David Karr -Sathish Tiptur -Lu Yunhai -Christian Ewald -Samuel Qi Luo -Sergey Logvin -Orlando Ribeiro -Doug Warner -Kevin Regan -Andy Olson -Max Voronoy -Alexandr Gavrilov -Scott Gunn -Mason Deaver -Richard Huber -Glen Osterhout -YingLi -Haka -Sam Chong -Virgilijus Globis -Stefan Scherer -Pim Philipse -Michael Grove -John Mackenzie -Ricky Marek -Patrick Maassen -Christian Schuhegger -David L Smith -Rainer Doerntge -Tompa -Derek Horton -Shameek Basu -Dipti Jain -Eric Zuur -Jeffrey J. Persch -Rahul Shukla -Pierre Fayolle -Greg McCain -Matt Cheers -Benjamin Fry -Ram Ben-Yakir -Eric Desamore -John Ashmun -Przemyslaw Marciniak -Carsten Madsen -David Sperry -Ted Horst -Diana Arroyo -Benny Prijono -Roland Ziegler -Stelios Sfakianakis -Mike Letchworth -Brian Gilmer -James Dunham -Juergen Pfreundt -Joel Sherrill -Jules Colding -Stephane Pion -Raghu Narayan -Richard Goold -Nathalie D'Amours -Albert Pariante -Stephen Torri -Philippe Perrin -Gunnar Buason -David Hanvey -Jeff McNiel -Georg Lohrer -Rachel G Smith -Tom Lake -Logan Modahala -Jean Malenfant -Victor Poznyak -Juan Jose Comellas -James Dorsey -Benot Desmeules -Tom Moog -Stan Pinte -Dayisi -Peter Georgakakis -Richard Hardgrave -Mark Drijver -Guy Bolton King -Carlton Teel -Alexandre Cervieri -Darren Griffith -Sam Mok -Josh Curry -Norman Wilson -Itzhak Briskman -James Kanyok -Corey Trager -Kirat Singh -Oleg Pavliv -Frederick Niemi -Andrew Munro -Nicolas Huynh -Kevin Burge -Wayne Erchak -Yew Khong See -Greg Thompson -Mike Pyle -Kobi Cohen-Arazi -Israel Illescas Gomez -Brodie Thiesfield -Erik Toubro Nielsen -Masaoud T. Moonim -Steve Witten -Gil Rapaport -Boris Temkin -Steve Perkins -Jerry Thomas -cuma -Ron Heald -Andrew Finnell -Dan Levi -Rob Andzik -James Maynard -Francois Rioux -Ophir Bleiberg -Allen Kelly -Victor Pitchouc -Srikanth Vedire -J Shane Culpepper -Steffen Hieber -Craig L. Ching -Ben Howard -Rich Newman -Kelly F. Hickel -David Trusty -Burkhard Neppert -Crawford Lodge -Scott Gaa -Jenny Kowald -Oren Zeev-Ben-Mordehai -Holger P. Krekel -Glenn Popelka -Tibor Kiss -Robert Davidson -Peter Crowther -Mouna Seri -Vladimir Chovanec -Alexander Rieger -Glen Coakley -Scott Plant -Wilfried Reinoehl -Sangeetha Ramadurai -Victor Chernenko -Frank Wolf -Christophe Galerne -Scott Harris -Stefan Kluehspies -Egon Wuchner -Ugendreshwar Kudupudi -Ekkehard Hoffmann -Ted Krovetz -Grzegorz Sikora -Fabris -Christina Junru -Patrick Rabau -Hyman Rosen -Torbjorn Backstrom -Robert Burke -Olivier Brunet -Bret Clark -Steve Rahn -Bertrand Motuelle -Blair Zajac -Gary Duzan -Garry Shamis -Eamonn Saunders -Yev Omenzel -John E Hein -Tino Schwarze -Gergely Timar -Peter Phillips -Yury Kuznesov -Daniel Manfis -Massimo Pichini -Eyal Neuman -Dave Hale -Giulio Agostini -Werner Buchert -Kevin Cline -Mahesh Varadarajan -Olof Lindfors -Tom Wagner -Kyle Brost -Vincent Nicolas -Jonathan Wackley -Jan Kalin -Andreas Huggel -Alain Totouom -Tushar Nair -Sunny Leung -Bonifides Bautista -Brad Hoskins -Donald Acton -Hagen Ulrich -Adrian Mercieca -Lars Steubesand -Heping He -Leo Kov -Suresh N -David Arndt -Tad Hetke -Graeme Clark -Gu Song -Chris Hughes -Fikri Pribadi -Ioulia Passynkova -Steve Osselton -Doron Rajwan -Stuart Jones -Guillaume Renaud -Tommy Svensson -Jstwo -Hartmut Quast -Ulrich Voigt -Syed Wasim Ali -Bo Balder -Michael Sawczyn -Ildar Gabdulline -David Yongqiang Wang -Shahzad Aslam-Mir -Andrew Foster -C Chan -Alexey Chalimov -Andrea Bernicchia -Praphul Menon -Patrick N -Garth Watney -Jim Connelly -Eyal Lubetzky -Gaoyan Xie -Michael Brinkmann -Chatchai Khumboa -Andrey Shkinev -Michael Graf -Justin Michel -Robert Martin -Charles Meidinger -Petr Tuma -Greg Burley -Marvin Greenberg -Mike Connors -Ben Flight -Bob Jolliffe -Jesse -Robert Handl -Keith Snively -Ahmed Riza -Miljenko Norsic -David Robison -Preston Elder -Eric Peters -Edward A Thompson -Eugene Alterman -Patrick Cosmo -Ran Kohavi -Harvinder Sawhney -Sorin Iordachescu -Mahesh Vedantam -Brian Olson -Roy Sharon -Charlie Grames -Tom Howard -Michael Gillmann -Yaniv Ben Ari -Victor Terber -David Sanders -Yoram Zini -Sean McCauliff -Shmulik Regev -Andrew L. Shwaika -Gerhard Voss -Gregor Bruce -Ian Cahoon -Alexei I. Adamovich -Sohail Husain -Jerome Julius -William R Volz -Koushik Banerjee -Zoran Cetusic -Patrick Bennett -Felix Wyss -Tim Rydell -Petr Shelomovsky -Juliana Diniz -Yuval Cohen -Timothy Kilbourn -Marc Walrave -Petru Marginean -Paresh Raote -Donna Maskell -Steve Ige -Marco Kranawetter -Christian Veleba -Olli Savia -Bhaskara Rao G -M Schulze -John Michael Zorko -Ami Bar -David Smith -Peter van Merkerk -Bill Dyer -Rodney Morris -Mark Hoffmann -Markus Wild -Joe Hayes -Chip Jones -Patrick J Lardieri -Ken O'Brien -Daniel Troesser -Ivan Pazymenko -Dan Green -Cyrille Chepelov -Peter Heitman -Paxton Mason -Yan Dai -Sean I. Luzader -Renjie Tang -Max V. Zinal -Stan Sosnovsky -Ariel Peltz -Carsten Prescher -Raghuram Shetty -Val Dumiterscu -Oleg Kraynov -Stephan Gudmundson -Frank Kuhlman -Denis Otchenashko -Marc M Adkins -Jon Lambert -Rainer Lucas -Allan S Iverson -Jeffrey Shaffer -Oleg Burlachenko -Jian Chen -Jeff Paciga -Laurent Sabourin -Frank Rybak -Tim Iskander -Michele Amoretti -Ido Yellin -Eric Page -Kevin Heifner -James Haiar -Pavel Repin -Whitney Kew -Tom Phan -Andrew Guy -Bharathi Kangatharan -Jean Quinsat -Ma Ting Chong -Andrew Sutton -Ansgar Konermann -Amir Kunst -Daniel Garrido -Andy Alvarez -Soeren Gerlach -Vitaly Prapirny -Sasha Agranov -Ruwanganie Gunatilleke -Peter Kullmann

-Lyn Headley -Jeff Adams -Alexander Maack -Timothy Culp -Oleg Terletsky -Bill Tonseth -Frank Pilhofer -Eric Quere -Keith Thornton -Nathan Krasney -Marek Maleta -David Smith -Dimitrije Jankovic -Frank O. Flemisch -Cary Steinmetz -Ty Tenait -Nitin Mallya -Nick Cross -Christopher W. Midgley -Wanjia -Shanliang Cheng -Andy Ling -Stephen Howard -Carsten T. Nielsen -Adee Ran - -Davide Pasetto -Michael Hornok -Wim van den Boogaard -Carol Hunsicker -Joseph Sarbak -Ruslan Zasukhin -Colin Weaver -Kew Whitney -Sean Ogle -Tim Bradley -Kier Schmitt -George Varsamis -Alan Tanga -Bertin Colpron -Jeff Wilson -Dmitry Khrapov -Francois -Laxmikant Bopalkar -Steven Gardner -Ronald Berger -Jeremy Altavilla -Brian Appel -Lan Zhineng -Leen Van Kampen -James Beale -Mark Xu -Umberto Mascia -Marcel Loose -Christian Klutz -Ville Lehtiniemi -Chumsu Kim -Schone Mullerin -Cemal Yimaz -Newton Aird -Frederic Motte -Roger Weeks -Gautam Thaker -Christophe Juniet -Jeff W -Geir Berset -Ken Sedgwick -Vince Mounts -Vladislav Zverev -Erich Hochmuth -Nick S. Petrov -Dmitry Botcharnikov -Philippe Haussy

-K2 -Eric Frias -Antonio Saraiva -Sean M. Paus -Yuanfang Zhang -Jonathan Franklin -Cristian Ungureanu -Tommy Persson -Christian Barheine -Ole Husgaard -Victor Kirk -Sandeep Neema -Mike Curtis -Artashes Ghazaryan -Ashok Sadasivan -Andreas Koehler -Thomas Devanneaux -Paul Marquis -Ed Skees -Marc Alter -Martin Geliot -Simon McQueen -Jason Pasion -Philipp Leibfried -Erwin Rol -Dirk Moermans -Huseyin Calgin -Jaroslaw Nozderko -Sharon Caspi -Thomas Natterer -Wilbur Lang -Rick Marlborough -David-A O-Brien -Shelton Tang -Frederic Langlet -Antonio Leonforte -Pablo d'Angelo -Christophe Vedel -Uwe Jaeger -Viktor Ransmayr -Daniel Bell -Mathias Waack -Mike Nordell -Tufan Oruk -Tim Smith -Andy King -Eric Strennen -Abhay Kulkarni -Ron Muck -Ma Weida -Terry Lao -Volker Boerchers -Tim Pullen -Marc Tardif -Guan Joe -Petr Ferschmann -Greg Mulyar -Max F. Bilyk -Danile White -Andrew Marlow -Michael F"olsl -Vincent Chau -Theo Landman -Igor Pisarenko -Dima Scub -Volodymyr Orlenko -Grigory -Michael Soden -Dennis Sporcic -Emmanuel Thevenot Beaufort -Denis Parnaland -Matthias Blankenhaus -Wolfgang Schroeder -Mario Hofmann -Bruce MacDonald -Jeffrey Graham -Otis Nyandoro -Ray Limpus -Dmitri Belogaj -Will Christof -Ferran Boladeres Salvad -Juan Carlos Montes Costa -Edward Scott -Steve Spencer -Fukasawa Mitsuo -Martin Brown -Terry Mihm -Jeff Gray -Rob Eger -Leonid Kvetnyi -Rudolf Weber -Sergei Pimenov -David Kinder -Sebastien Lalonde -Jia Wan -Bertin Colpron -Weston Markham -Bryan Thrall -Subhabrata Biswas -Dave Ryan -Zsolt Zsoldos -Tongzhe Cui -Braden McDaniel -Richard Woodring -Andras Lang -Scott Gammil -Nick Lewycky -Ira Burton -Thomas Wiegert -Craig Watcham -Pit Linnartz -Peder Norgaard -David Ohlemacher -Ken Kane -Bill Church -Udo Berninger -Vincent Korkos -Martin Corino -Terry Lacy -Branko Mijic -Jeff Kelley -Daniel Hannum -Jason Cohen -Nick Kukuczka -Andrew Voumard -Anand -D.J. Dwyer -Douglas A Stuart -Victor N. -Francesco Baldi -Michael Rice -Jesse Greenwald -Raymond Hoofman -Jason Smith -Danta Cannarozzi -Valery Salamakha -Karim Fodil-Lemelin -Wenlong Tang -Manish Jain -Robin Farine -Roland Schimmack -Roy Pollock -Eric Held -Kees van Marle -Dieter Knueppel -Amol Tambe -Emiliano Berenbaum -Scott Clarke -Sunil Rottoo -Martin Habets -Todd Cooper -Serkan Unsal -Milan Cvetkovic -Didier Becu -Dan Halbert -Jerome Waibel -Stephan Frenzel -Bruce Jones -Tim Hawes -Philip Leishman -Alexander Jasper -Gerard Grant -Trevor Fields -Jeff Dugan -Jeff Mirwaisi -Alain Dupont -Stephan Bettermann -David McKen -Adam Fanello -Matthieu Vansteene -Sean Rooney -Enrico Detoma -Onopin V. Mikhail -Edward R. Mulholland -Brian Buesker -Vladimir Naylov -Ted Mules -Mike Hepburn -Dale Wilson -Thomas Girard -Malcolm McRoberts -Dror Tirosh -Chris Sontag -Moran Levi -UV Wildner -Alan l Batongbacal -Gary Maxey -Yoav Borer -Andre Kleibeuker -Andy Bellafaire -John Fletcher -Terry Ware -Pierre Pacchioni -Roger Beathard -Konstantinos Margaritis -Stephen Procter -Christoph Liebig -Andre Kostur -Markus Stenberg -Jonathan Pollack -Si Mong Park -Hakim Souami -Paul Morrison -John Poplett -Heiko Bachmann -Andrew Metcalfe -Simon Dutkowski -Mickael P. Golovin -Shannon Barber -Brad Orner -Michelangelo Nottoli -Peter Bekiesch -Martin Kaul -Lukas Gruetzmacher -Robert Schiele -Matthew Grosso -Akim Boyko -Nils Sandoy -Daniel Miranda -Hans-Peter Bock -Dmitri Hrapof -Denny Kolb -Daniel Buchs -Matt Murphy -Brian Nelson -Avi Ouziel -Matthew Gillen -Chris Reed -Andrew Reid -Praveen Sharma -Yi Zuo -Raphael Bossek -Richard G. Hash -Karl Tredwell -Norm Whitehead -Jiang Wei -Kevin Bryan -Zvika Ashani -Thomas Costa -Dom Monteiro -Jean-Marc Prud'homme -Yury Osadchy -Pavan Mandalkar -Scott Willey -David Calkins -Wu Yongwei -Karen L. Regner -Michel Drapeau -Hans Bos -Kevin Stacy -Liat -Andreas Wagner -Steven Xie -Kris Dekeyser -Matthew Harris -Abhijit Sachdev -Mikael Lundqvist -Peter Hercek -Jay Welch -Angel Roman -Jessica Pistole -Paolo Carlini -Eric Whorter -Vincent Seignole -Jingbin An -Roland Meub -Marek Brudka -Levente Torok -Panagiotis Issaris -Mehrdad Nazari -Pierre Bisaillon -Rob Boyer -Scott Gammill -Bayu Hendradjaya -Randy Hammon -Bill Cassanova -Matthew Corey -Vinod Kumar -Mirek Pabich -Christian Egeler -J.T. Conklin -Dale Hawkins -Bill Hopkins -David Fleeman -Merlin Ran -Kevin Christian -Trina Wisler -Bae-Sik Chon -Benjamin Bronk -Dave Craig -Ofira Shaer -Ciaran Moran -Thomas Rohner -Ken Descoteaux -Claas-Hinrich Dommreis -Yateen Joshi -Sergei Kuchin -Theckla Louchios -Randy Secrest -Patrice Marques -Stanislaw Trytek -Mattias Nilsson -Michael Hollins -Dave Knox -Lance Paine -Brian Waltersdorf -Johann Kandlbauer -Adam Rymarczuk -Heiko Nardmann -J. Abelardo Gutierrez -Roger Sala -Razi Ben-Yehuda -Geo Sebastian -Simon Massey -Rich Shapiro -Ramiro Morales -Andrew Athan -Sebastien Roy -Matthew Townsend -Rick Robinson -John D. Robertson -Paul Lew -Eider Oliveira -Jeff Jones -Jean-Christophe Cota -Paul -Vincent Newsum -Vasili Goutas -Iliyan Jeliazkov -Shlomi Yaakobovich -Todd Marshall -Ciju John -Yuk Ming Kwok -Honorato Saavedra -Domingos Monteiro -Bill Somerville -Bjorn Roald -Michi Henning -Xue Yong Zhi -Ertugrul Sorar -Simone Viani -Rohan Mars -Robert S. Iakobashvili -Chris Hammond -Vincent Spano -Nuno Silva -Greg Bostrum -Dipa Suri -Adam Howell -Steven Frare -Dave Dalapati -Arjun Thounaojam -Michael Altmann -Steven Patrick -Pete McCann -William Nagel -M. C. Gahan -Thia Chang Chao -Gao Xianchao -Huang Rui -Sam Abbe -Mike McGahan -David Michael -Steve D. Baker -Martina Yen -Kim ByeongSu -Doug McCorkle -YiQing Xiong -Peter Falsh -Don Sharp -Arto Jalkanen -Scott Zionic -Diana Ukleja -Shaun Cooley -Aapo M�kinen -Matt Emerson -Sean Parker -Mark Wilson -Joerg Rockel -Phil Chen -Stefan Morrow -Bruce Elliot -Mitscher Dubreus -Brian O'Connor -Ron Wilson -Peter Grotrian -Alex Ott -D. J. Stachniak -Slava Gorelik -Wolfgang Fischer -Nicholas Todd -Arno Wilhelm -Andreas Schuler -Altaf Aali -Vemund Handeland -Mario Di Giacomo -Raoul Gough -Aaron -Rohini Madhavan -Alan Balasuar -Will Chai -Paul Koch -Dave Giovannini -Dave Varnell -Howard Finer -Mark Callaghan -Hanson Lu -Gavin Yu -Srikanth Gopal -Like Ma -Alvin Msg -Angela Ziegenhorn -Sam Mesh -Felix Perez Alamillo -Steven T. Hatton -Yevgen Galchenko -Timothy Wayne Gomez -Ventimiglia Chere -Frederick Heckel -Ian Zagorskih -Olivier Gu�rin -Abdel Rigumye -James Damour -Alan Anderson -Vito Bico -Aldo Texier -J H Choi -Mike Chartier -Nikolay Metchev -Anand Rathi -Vitaly Belekhov -Dorian Hileaga -Steve Williams -Paul Friberg

-Zachi Klopman -Jin Zhi Ye -David Carlton -Feng Li -Michael van der Westhuizen -Jan Zima -Francesco Salvestrini -Sandeep Deshpande -Hubert Talbot -Oh Yoon Sik -Anton Bakanovskiy -Toha Bakanovsky -David Faure -Robert Hancock -Peter Oslej -Yongming Wang -Vadim Iosevich -Mike Knight -Nathan Anderson -Eyal Car -Jonathan Sprinkle -Vladimir Panov -Volker Lukas -Bryan Cassell -Guy Peleg -Wallace Zhang -Richard Ward -Alan Stokes -Rick Taylor -Tobias Herzke -Paul Felix -Jan Ohlenburg -Eric Tiangang -David Hawkins -Michael Klein -Sandro Santos Andrade -Richard Spence -Thomas E Lackey -luxi78 at gmail dot com -John Lilley -Abdullah Sowayan -Nathan Bamford -Zoltan Molnar -William Byrne -Karl Schmitt -Ron DeAngelis -Alex Sheh -Daniel Wagner <__daniel___ at icg do tu-graz dot ac dot at> -Nemoy Michael -Marc Brown -Andrew Keane -Martin Kolleck -Tino Riethmueller -Adam Mitz -Frank Rehberger -Aaron Scamehorn -Alan Kierstead -Sven-Uwe Sieler-Hornke -Spencer Vanroekel -Dan Pozdol -Yauheni Akhotnikau -Axter -Roopa Pundaleeka -JR Andreassen -Mockey Chen -Vincent Joseph -Igor Mammedov -Yuan -Adrian Tulloch -Dmitriy Kuznetsov -Steve Orner -Bob Ronak -Aleksandar Vukajlovic -esIgnacio Alvarez -Sergey Zubarev -Qingbo Cai -David White -Jason Zhang -Mark Paulus -Willie Chen -Martin Cornelius -Mohit Kapoor -David Gibbs -Gary Fernandez -Jason Zhao -Keith Muzzioli -John Black -David Chu -Kevin Hu -Yasser Zabuair -Phlip -Michelle Zheng -Gerolf Reinwardt -Paul Robinson -Popeye Cai -David Highley -Sonicfly Zhou -Phil Billingham -Paul Daugherty -Robert Schwebel -William Cote -Ben Creech -Michael Reed -Heesuk Shin -Hong Xing -Winston Zhang -Stefan Naewe -Graeme Bell -Eric Danielou -Wei Jiang -Dale Boan -Christoph Schmalhofer -Amnon Berger -Ephy Levy -Don Meek -Liu Qian -Nzer Zaidenberg -Birgit Platt -Andy Salnikov -Hieu Ngyuen -Andriy Gapon -Andy Wang -Zhamak Dehghani -Charles Calkins -Manuel Traut -Drew Reynaud -Artur DeEsperanto -Scott Mitchell -Thomas Vanier -N Johnson -Adam Nagel -Robert Neumann -Venkat -Juraj Ivancic -Daniel Black -Richard Ridgway -Vadym Ridosh -Viola Wang -Ray Lischner -Sergey Kosenko -Pavel Zaichenko -Paul Riley -Nelson Filipe Ferreira Gon�alves -Harry Goldschmitt -Sail Zeng -Markus Henschel -Asif Lodhi -Andrew Schnable -Grigoriy Zeleniy -Yves Alloyer -Waba -Scott Mark -Bjoern Rasmussen -Ian C White -Dennis Chernoivanov -Werner Burger -Andres Hurtis -Joe French -M. Arshad Khan -Hans van't Hag -Roland Sun -Vance Maverick -John McCabe -Andres Oportus -Olof Granered -Eric Hughes -Zhenghao Shi -Alexander Kornienko -Ben Mohlenhoff -Bill Bruns -Dmitriy Nikitinskiy -Ravi Kanth -Ian Roberts -Patrick Spiering -Duane Beck -Kanghee Yoon -Xu Liang -Leo Lei -Jules d'Entremont -Rajiv K. Shukla -Haibin Zhang -Vikram Karandikar -Kim J. Schmock -Venkat Forums -James Marsh -Shaolong Xiang -Christoph Hofmann -Vladimir Zykov -Daniel de Angelis Cordeiro -Hal Black -Peter Korf -Norbert Thoden -Premkumar P -David Beck -Hayim Shaul -Erman Balcik -Torsten Saliwada -Nathan Glasser -Gr�gor Boirie -Alex Solan -Venkat Sidhabathuni -Nathan Ernst -Kun Niu -Karl-Heinz Wind -Oliver Spang -Hu Yi -Joe Seward -Tom Callaway -Alick Nie -Douglas Atique -Nayeem Khan -Sorin Voicu-Comendant -Andi Heusser -Paul Carter -Michael Carter -Alain Kocelniak -Alvaro Vega Garcia -Fernando C. Jeronymo -Stephen Mouring -Tim -Thomas Brownridge -June Fang -Bill Kendall -Ittehad Shaikh -Michael Doubez -Namrata Gandhi <...> -Michael Guntli -Frank F�rster -Roger Leblanc -Bob Fiske -Julien Vintrou -Jonathan Brannan -antred -Nathalie D'Amours -Mele Giovanni -Philipp Thomas -Mark Hebbel -Tim Pollock -Jack Lavender -Alexandre Skrzyniarz -E Vahala -Christian Fromme -Daniel Lang -Greg Bothe -Anand Kumar -Joe Pallas -Marcel Smit -Florent Vial -Pan Kai Luna -Jesus Martinez -Martin Gaus -Steve Stallion -Ron van Hoof -Joe Lihn -Jani Hakala -Marcus Monaghan -Kashif Khan -JD Robertson -Andreas Drescher -Alon Diamant -Igor Rayak -Shai Kedem -Steve Ramsay - -Skrzyniarz Alexandre -Rob Beekmans -Steven Hartmann -Dicky -Boyan Kasarov -Brendan Murphy -Ryan Carmichael -Koh Onishi -Markus Gaugusch -Annette Wilson -Sharon Mizrahi -William Glenn -Christian Ehrlicher -Hui Zhang -Marijke Hengstmengel -Christian Freund -Chris Shaw -Matthew Carter -Denis Budko -Gaurav Kulshreshtha -Wolfgang Pickartz -Joost Kraaijeveld -Pau Garcia i Quiles -Sail Zeng -Dirk Bonekaemper -Sreejith -Guillaume Lahaye -Andrew Kaplan -Alexander Mintz -Jennifer Kahng -Trent Nadeau -Nick Meyer -Olivier Langlois -Patrick Soboljew -Tim Pinkawa -Ed Blackmond -Dave -Inma Perea -David Ward -Anatoli Sakhnik -Max Zhou -Daynesh Mangal -Robert Shectman -Rafi -Kannan Ramaswamy -Brian Johnson -Catherine L. Paquin -Susan Finster -Frank Preischl -Matthew Waller -Elez -Ranjit Hande -Van Vuong -Mark -Wendsomde Yameogo -Shi John -Helmut Böing -Andrew Hill -Henk Jan Priester -Glenn Zickert -Chris Galli -Laura Autón García -Jonathan Saxton -Remko Duppen -Paul Fitzpatrick -Chad Beaulac -Jochen Meier -Thomas Pauli -Qiao Zhiqiang -JaeSung Lee -Chong Wuk Pak -Michael Frommberger -Andrey Karpov -Dmytro Ovdiienko -Andrea Sormanni -Thomas Stegemann -David Simmonds -Andreas Dröscher -Markus Manck -Deux deVille -Mohsin Zaidi -Milind Pangarkar -Ali Akbar Zarezadeh -Andrés Senac González -Peng Xu -Sergey Onuchin -Michael Ganz -Phillip LaBanca -Journeyer J. Joh -Rudy Pot -Neil Youngman -Andreas Florath -Clyde Gerber -George Chen -Piotr Kow -Yogesh Sharma -Mike McKnerney -Mike Ketchen -Erik Sohns -Winston Jenks -Colin Shen -Alexey Zubko -Michael Dille -Sebastian Perk -David Lifshitz -Milo H. Fields -Thomas Schmidt -Joe Zendle -Cesar Mello - -I would particularly like to thank Paul Stephenson, who worked with me -at Ericsson in the early 1990's. Paul devised the recursive Makefile -scheme that underlies the ACE distribution and also spent countless -hours with me discussing object-oriented techniques for developing -distributed application frameworks. - -Finally, I'd also like to thank Todd L. Montgomery , -fellow heavy metal head, for fulfilling his quest to get ACE to -compile with GCC! - -In conclusion, our goal is to see ACE+TAO+CIAO continue to evolve and -become a more comprehensive, robust, and well-documented C++ class -library that is freely available to researchers and developers. If -you have any improvements, suggestions, and or comments, we'd like to -hear about it. Please see the instructions in - -$ACE_ROOT/PROBLEM-REPORT-FORM -$TAO_ROOT/PROBLEM-REPORT-FORM -$CIAO_ROOT/PROBLEM-REPORT-FORM -$DANCE_ROOT/PROBLEM-REPORT-FORM - -for instructions on submitting suggestions or fixes. - - Thanks, - - Douglas C. Schmidt - d.schmidt at vanderbilt.edu diff --git a/deps/acelite/VERSION.txt b/deps/acelite/VERSION.txt deleted file mode 100644 index b37ee3db0..000000000 --- a/deps/acelite/VERSION.txt +++ /dev/null @@ -1,8 +0,0 @@ -This is ACE version 6.5.10, released Wed Jul 01 09:54:36 CEST 2020 - -If you have any problems with or questions about ACE, please send -e-mail to the ACE mailing list (ace-bugs@list.isis.vanderbilt.edu), -using the form found in the file PROBLEM-REPORT-FORM. In order -to post to the list you must subscribe to it. - -See http://www.dre.vanderbilt.edu/~schmidt/ACE-mail.html diff --git a/deps/acelite/ace/ACE.cpp b/deps/acelite/ace/ACE.cpp deleted file mode 100644 index 0ff5080d6..000000000 --- a/deps/acelite/ace/ACE.cpp +++ /dev/null @@ -1,3495 +0,0 @@ -#include "ace/ACE.h" - -#include "ace/Basic_Types.h" -#include "ace/Handle_Set.h" -#include "ace/Auto_Ptr.h" -#include "ace/SString.h" -#include "ace/Version.h" -#include "ace/Message_Block.h" -#include "ace/Log_Category.h" -#include "ace/Flag_Manip.h" -#include "ace/OS_NS_sys_select.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_NS_strings.h" -#include "ace/OS_NS_signal.h" -#include "ace/OS_NS_stdio.h" -#include "ace/OS_NS_sys_resource.h" -#include "ace/OS_NS_sys_wait.h" -#include "ace/OS_NS_sys_time.h" -#include "ace/OS_NS_time.h" -#include "ace/OS_NS_sys_uio.h" -#include "ace/OS_NS_sys_stat.h" -#include "ace/OS_NS_ctype.h" -#include "ace/OS_NS_fcntl.h" -#include "ace/OS_TLI.h" -#include "ace/Truncate.h" - -#if !defined (__ACE_INLINE__) -#include "ace/ACE.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_HAS_POLL) -# include "ace/OS_NS_poll.h" -#endif /* ACE_HAS_POLL */ - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -namespace ACE -{ - // private: - // Used internally so not exported. - - // Size of allocation granularity. - size_t allocation_granularity_ = 0; - - // Size of a VM page. - size_t pagesize_ = 0; - - // Are we debugging ACE? - // Keeps track of whether we're in some global debug mode. - char debug_; -} - - -int -ACE::out_of_handles (int error) -{ - // EMFILE is common to all platforms. - if (error == EMFILE || -#if defined (ACE_WIN32) - // On Win32, we need to check for ENOBUFS also. - error == ENOBUFS || -#elif defined (HPUX) - // On HPUX, we need to check for EADDRNOTAVAIL also. - error == EADDRNOTAVAIL || -#elif defined (ACE_LINUX) - // On linux, we need to check for ENOENT also. - error == ENOENT || - // For RedHat5.2, need to check for EINVAL too. - error == EINVAL || - // Without threads check for EOPNOTSUPP - error == EOPNOTSUPP || -#elif defined (sun) - // On sun, we need to check for ENOSR also. - error == ENOSR || - // Without threads check for ENOTSUP - error == ENOTSUP || -#elif defined (__FreeBSD__) - // On FreeBSD we need to check for EOPNOTSUPP (LinuxThreads) or - // ENOSYS (libc_r threads) also. - error == EOPNOTSUPP || - error == ENOSYS || -#elif defined (__OpenBSD__) - // OpenBSD appears to return EBADF. - error == EBADF || -#endif /* ACE_WIN32 */ - error == ENFILE) - return 1; - else - return 0; -} - -u_int -ACE::major_version (void) -{ - return ACE_MAJOR_VERSION; -} - -u_int -ACE::minor_version (void) -{ - return ACE_MINOR_VERSION; -} - -u_int -ACE::beta_version (void) -{ - return ACE_BETA_VERSION; -} - -u_int -ACE::micro_version (void) -{ - return ACE_MICRO_VERSION; -} - -const ACE_TCHAR * -ACE::compiler_name (void) -{ -#ifdef ACE_CC_NAME - return ACE_CC_NAME; -#else - return ACE_TEXT (""); -#endif -} - -u_int -ACE::compiler_major_version (void) -{ -#ifdef ACE_CC_MAJOR_VERSION - return ACE_CC_MAJOR_VERSION; -#else - return 0; -#endif -} - -u_int -ACE::compiler_minor_version (void) -{ -#ifdef ACE_CC_MINOR_VERSION - return ACE_CC_MINOR_VERSION; -#else - return 0; -#endif -} - -u_int -ACE::compiler_beta_version (void) -{ -#ifdef ACE_CC_BETA_VERSION - return ACE_CC_BETA_VERSION; -#else - return 0; -#endif -} - -ACE_TCHAR -ACE::nibble2hex (u_int n) -{ - // Yes, this works for UNICODE - return ACE_TEXT ("0123456789abcdef")[n & 0x0f]; -} - -bool -ACE::debug (void) -{ - //FUZZ: disable check_for_ace_log_categories - static const char *debug = ACE_OS::getenv ("ACE_DEBUG"); - //FUZZ: enable check_for_ace_log_categories - return (ACE::debug_ != 0) ? ACE::debug_ : (debug != 0 ? (*debug != '0') : false); -} - -void -ACE::debug (bool onoff) -{ - ACE::debug_ = onoff; -} - -int -ACE::select (int width, - ACE_Handle_Set *readfds, - ACE_Handle_Set *writefds, - ACE_Handle_Set *exceptfds, - const ACE_Time_Value *timeout) -{ - int result = ACE_OS::select (width, - readfds ? readfds->fdset () : 0, - writefds ? writefds->fdset () : 0, - exceptfds ? exceptfds->fdset () : 0, - timeout); - if (result > 0) - { -# if !defined (ACE_WIN32) - // This isn't needed for Windows... it's a no-op anyway. - if (readfds) - readfds->sync ((ACE_HANDLE) width); - if (writefds) - writefds->sync ((ACE_HANDLE) width); - if (exceptfds) - exceptfds->sync ((ACE_HANDLE) width); -#endif /* ACE_WIN32 */ - } - return result; -} - -int -ACE::select (int width, - ACE_Handle_Set &readfds, - const ACE_Time_Value *timeout) -{ - int result = ACE_OS::select (width, - readfds.fdset (), - 0, - 0, - timeout); - -#if !defined (ACE_WIN32) - if (result > 0) - readfds.sync ((ACE_HANDLE) width); -#endif /* ACE_WIN32 */ - return result; -} - -int -ACE::terminate_process (pid_t pid) -{ -#if defined (ACE_HAS_PHARLAP) - ACE_UNUSED_ARG (pid); - ACE_NOTSUP_RETURN (-1); -#elif defined (ACE_WIN32) - // Create a handle for the given process id. - ACE_HANDLE process_handle = - ::OpenProcess (PROCESS_TERMINATE, - FALSE, // New handle is not inheritable. - pid); - - if (process_handle == ACE_INVALID_HANDLE - || process_handle == 0) - return -1; - else - { - // Kill the process associated with process_handle. - BOOL terminate_result = - ::TerminateProcess (process_handle, 0); - // Free up the kernel resources. - ACE_OS::close (process_handle); - return terminate_result ? 0 : -1; - } -#else - return ACE_OS::kill (pid, 9); -#endif /* ACE_HAS_PHARLAP */ -} - -int -ACE::process_active (pid_t pid) -{ -#if !defined(ACE_WIN32) - if (ACE_OS::kill (pid, 0) == 0) - return 1; - else if (errno == ESRCH) - return 0; - else - return -1; -#else - // Create a handle for the given process id. - ACE_HANDLE process_handle = - ::OpenProcess (PROCESS_QUERY_INFORMATION, FALSE, pid); - if (process_handle == ACE_INVALID_HANDLE || process_handle == 0) - return 0; - else - { - DWORD status; - int result = 1; - if (::GetExitCodeProcess (process_handle, - &status) == 0 - || status != STILL_ACTIVE) - result = 0; - - ::CloseHandle (process_handle); - return result; - } -#endif /* !ACE_WIN32 */ -} - -const ACE_TCHAR * -ACE::execname (const ACE_TCHAR *old_name) -{ -#if defined (ACE_WIN32) - const ACE_TCHAR *suffix = ACE_OS::strrchr (old_name, ACE_TEXT ('.')); - if (suffix == 0 || ACE_OS::strcasecmp (suffix, ACE_TEXT (".exe")) != 0) - { - ACE_TCHAR *new_name = 0; - - size_t size = - ACE_OS::strlen (old_name) - + ACE_OS::strlen (ACE_TEXT (".exe")) - + 1; - - ACE_NEW_RETURN (new_name, - ACE_TCHAR[size], - 0); - ACE_TCHAR *end = new_name; - - end = ACE_OS::strecpy (new_name, old_name); - - // Concatenate the .exe suffix onto the end of the executable. - // end points _after_ the terminating nul. - ACE_OS::strcpy (end - 1, ACE_TEXT (".exe")); - - return new_name; - } -#endif /* ACE_WIN32 */ - return old_name; -} - -u_long -ACE::hash_pjw (const char *str, size_t len) -{ - u_long hash = 0; - - for (size_t i = 0; i < len; i++) - { - const char temp = str[i]; - hash = (hash << 4) + (temp * 13); - - u_long g = hash & 0xf0000000; - - if (g) - { - hash ^= (g >> 24); - hash ^= g; - } - } - - return hash; -} - -u_long -ACE::hash_pjw (const char *str) -{ - return ACE::hash_pjw (str, ACE_OS::strlen (str)); -} - -#if defined (ACE_HAS_WCHAR) -u_long -ACE::hash_pjw (const wchar_t *str, size_t len) -{ - u_long hash = 0; - - for (size_t i = 0; i < len; i++) - { - // @@ UNICODE: Does this function do the correct thing with wchar's? - - const wchar_t temp = str[i]; - hash = (hash << 4) + (temp * 13); - - u_long g = hash & 0xf0000000; - - if (g) - { - hash ^= (g >> 24); - hash ^= g; - } - } - - return hash; -} - -u_long -ACE::hash_pjw (const wchar_t *str) -{ - return ACE::hash_pjw (str, ACE_OS::strlen (str)); -} -#endif /* ACE_HAS_WCHAR */ - -ACE_TCHAR * -ACE::strenvdup (const ACE_TCHAR *str) -{ - ACE_TRACE ("ACE::strenvdup"); - - return ACE_OS::strenvdup (str); -} - -/* - -Examples: - -Source NT UNIX -================================================================== -netsvc netsvc.dll libnetsvc.so -(PATH will be (LD_LIBRARY_PATH -evaluated) evaluated) - -libnetsvc.dll libnetsvc.dll libnetsvc.dll + warning -netsvc.so netsvc.so + warning libnetsvc.so - -..\../libs/netsvc ..\..\libs\netsvc.dll ../../libs/netsvc.so -(absolute path used) (absolute path used) - -*/ - -const ACE_TCHAR * -ACE::basename (const ACE_TCHAR *pathname, ACE_TCHAR delim) -{ - ACE_TRACE ("ACE::basename"); - const ACE_TCHAR *temp = ACE_OS::strrchr (pathname, delim); - - if (temp == 0) - return pathname; - else - return temp + 1; -} - -const ACE_TCHAR * -ACE::dirname (const ACE_TCHAR *pathname, ACE_TCHAR delim) -{ - ACE_TRACE ("ACE::dirname"); - static ACE_TCHAR return_dirname[MAXPATHLEN + 1]; - - const ACE_TCHAR *temp = ACE_OS::strrchr (pathname, delim); - - if (temp == 0) - { - return_dirname[0] = '.'; - return_dirname[1] = '\0'; - - return return_dirname; - } - else - { - // When the len is truncated, there are problems! This should - // not happen in normal circomstances - size_t len = temp - pathname + 1; - if (len > (sizeof return_dirname / sizeof (ACE_TCHAR))) - len = sizeof return_dirname / sizeof (ACE_TCHAR); - - ACE_OS::strsncpy (return_dirname, - pathname, - len); - return return_dirname; - } -} - -ssize_t -ACE::recv (ACE_HANDLE handle, - void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout) -{ - if (timeout == 0) - return ACE_OS::recv (handle, (char *) buf, len, flags); - else - { - int val = 0; - if (ACE::enter_recv_timedwait (handle, timeout, val) ==-1) - return -1; - else - { - ssize_t bytes_transferred = - ACE_OS::recv (handle, (char *) buf, len, flags); - ACE::restore_non_blocking_mode (handle, val); - return bytes_transferred; - } - } -} - -#if defined (ACE_HAS_TLI) - -ssize_t -ACE::t_rcv (ACE_HANDLE handle, - void *buf, - size_t len, - int *flags, - const ACE_Time_Value *timeout) -{ - if (timeout == 0) - return ACE_OS::t_rcv (handle, (char *) buf, len, flags); - else - { - int val = 0; - if (ACE::enter_recv_timedwait (handle, timeout, val) ==-1) - return -1; - else - { - ssize_t bytes_transferred = - ACE_OS::t_rcv (handle, (char *) buf, len, flags); - ACE::restore_non_blocking_mode (handle, val); - return bytes_transferred; - } - } -} - -#endif /* ACE_HAS_TLI */ - -ssize_t -ACE::recv (ACE_HANDLE handle, - void *buf, - size_t n, - const ACE_Time_Value *timeout) -{ - if (timeout == 0) - return ACE::recv_i (handle, buf, n); - else - { - int val = 0; - if (ACE::enter_recv_timedwait (handle, timeout, val) == -1) - return -1; - else - { - ssize_t bytes_transferred = ACE::recv_i (handle, buf, n); - ACE::restore_non_blocking_mode (handle, val); - return bytes_transferred; - } - } -} - -ssize_t -ACE::recvmsg (ACE_HANDLE handle, - struct msghdr *msg, - int flags, - const ACE_Time_Value *timeout) -{ - if (timeout == 0) - return ACE_OS::recvmsg (handle, msg, flags); - else - { - int val = 0; - if (ACE::enter_recv_timedwait (handle, timeout, val) == -1) - return -1; - else - { - ssize_t bytes_transferred = ACE_OS::recvmsg (handle, msg, flags); - ACE::restore_non_blocking_mode (handle, val); - return bytes_transferred; - } - } -} - -ssize_t -ACE::recvfrom (ACE_HANDLE handle, - char *buf, - int len, - int flags, - struct sockaddr *addr, - int *addrlen, - const ACE_Time_Value *timeout) -{ - if (timeout == 0) - return ACE_OS::recvfrom (handle, buf, len, flags, addr, addrlen); - else - { - int val = 0; - if (ACE::enter_recv_timedwait (handle, timeout, val) == -1) - return -1; - else - { - ssize_t bytes_transferred = - ACE_OS::recvfrom (handle, buf, len, flags, addr, addrlen); - ACE::restore_non_blocking_mode (handle, val); - return bytes_transferred; - } - } -} - -ssize_t -ACE::recv_n_i (ACE_HANDLE handle, - void *buf, - size_t len, - int flags, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - ssize_t n; - - for (bytes_transferred = 0; - bytes_transferred < len; - bytes_transferred += n) - { - // Try to transfer as much of the remaining data as possible. - n = ACE_OS::recv (handle, - static_cast (buf) + bytes_transferred, - len - bytes_transferred, - flags); - // Check EOF. - if (n == 0) - return 0; - - // Check for other errors. - if (n == -1) - { - // Check for possible blocking. - if (errno == EWOULDBLOCK) - { - // Wait for the blocking to subside. - int const result = ACE::handle_read_ready (handle, 0); - - // Did select() succeed? - if (result != -1) - { - // Blocking subsided. Continue data transfer. - n = 0; - continue; - } - } - - // Other data transfer or select() failures. - return -1; - } - } - - return static_cast (bytes_transferred); -} - -ssize_t -ACE::recv_n_i (ACE_HANDLE handle, - void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - ssize_t n; - ssize_t result = 0; - int error = 0; - - int val = 0; - ACE::record_and_set_non_blocking_mode (handle, val); - - for (bytes_transferred = 0; - bytes_transferred < len; - bytes_transferred += n) - { - // Try to transfer as much of the remaining data as possible. - // Since the socket is in non-blocking mode, this call will not - // block. - n = ACE_OS::recv (handle, - static_cast (buf) + bytes_transferred, - len - bytes_transferred, - flags); - - // Check for errors. - if (n == 0 || - n == -1) - { - // Check for possible blocking. - if (n == -1 && - errno == EWOULDBLOCK) - { - // Wait upto for the blocking to subside. - int const rtn = ACE::handle_read_ready (handle, timeout); - - // Did select() succeed? - if (rtn != -1) - { - // Blocking subsided in period. Continue - // data transfer. - n = 0; - continue; - } - } - - // Wait in select() timed out or other data transfer or - // select() failures. - error = 1; - result = n; - break; - } - } - - ACE::restore_non_blocking_mode (handle, val); - - if (error) - return result; - else - return static_cast (bytes_transferred); -} - -#if defined (ACE_HAS_TLI) - -ssize_t -ACE::t_rcv_n_i (ACE_HANDLE handle, - void *buf, - size_t len, - int *flags, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - ssize_t n; - - for (bytes_transferred = 0; - bytes_transferred < len; - bytes_transferred += n) - { - // Try to transfer as much of the remaining data as possible. - n = ACE_OS::t_rcv (handle, - (char *) buf + bytes_transferred, - len - bytes_transferred, - flags); - // Check EOF. - if (n == 0) - return 0; - - // Check for other errors. - if (n == -1) - { - // Check for possible blocking. - if (errno == EWOULDBLOCK) - { - // Wait for the blocking to subside. - int const result = ACE::handle_read_ready (handle, 0); - - // Did select() succeed? - if (result != -1) - { - // Blocking subsided. Continue data transfer. - n = 0; - continue; - } - } - - // Other data transfer or select() failures. - return -1; - } - } - - return bytes_transferred; -} - -ssize_t -ACE::t_rcv_n_i (ACE_HANDLE handle, - void *buf, - size_t len, - int *flags, - const ACE_Time_Value *timeout, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - ssize_t n; - ssize_t result = 0; - int error = 0; - - int val = 0; - ACE::record_and_set_non_blocking_mode (handle, val); - - for (bytes_transferred = 0; - bytes_transferred < len; - bytes_transferred += n) - { - // Try to transfer as much of the remaining data as possible. - // Since the socket is in non-blocking mode, this call will not - // block. - n = ACE_OS::t_rcv (handle, - (char *) buf + bytes_transferred, - len - bytes_transferred, - flags); - - // Check for errors. - if (n == 0 || - n == -1) - { - // Check for possible blocking. - if (n == -1 && - errno == EWOULDBLOCK) - { - // Wait upto for the blocking to subside. - int const rtn = ACE::handle_read_ready (handle, timeout); - - // Did select() succeed? - if (rtn != -1) - { - // Blocking subsided in period. Continue - // data transfer. - n = 0; - continue; - } - } - - // Wait in select() timed out or other data transfer or - // select() failures. - error = 1; - result = n; - break; - } - } - - ACE::restore_non_blocking_mode (handle, val); - - if (error) - return result; - else - return bytes_transferred; -} - -#endif /* ACE_HAS_TLI */ - -ssize_t -ACE::recv_n_i (ACE_HANDLE handle, - void *buf, - size_t len, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - ssize_t n; - - for (bytes_transferred = 0; - bytes_transferred < len; - bytes_transferred += n) - { - // Try to transfer as much of the remaining data as possible. - n = ACE::recv_i (handle, - static_cast (buf) + bytes_transferred, - len - bytes_transferred); - // Check EOF. - if (n == 0) - { - return 0; - } - // Check for other errors. - if (n == -1) - { - // Check for possible blocking. - if (errno == EWOULDBLOCK) - { - // Wait for the blocking to subside. - int const result = ACE::handle_read_ready (handle, 0); - - // Did select() succeed? - if (result != -1) - { - // Blocking subsided. Continue data transfer. - n = 0; - continue; - } - } - - // Other data transfer or select() failures. - return -1; - } - } - - return static_cast (bytes_transferred); -} - -ssize_t -ACE::recv_n_i (ACE_HANDLE handle, - void *buf, - size_t len, - const ACE_Time_Value *timeout, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - ssize_t n; - ssize_t result = 0; - int error = 0; - - int val = 0; - ACE::record_and_set_non_blocking_mode (handle, val); - - for (bytes_transferred = 0; - bytes_transferred < len; - bytes_transferred += n) - { - // Try to transfer as much of the remaining data as possible. - // Since the socket is in non-blocking mode, this call will not - // block. - n = ACE::recv_i (handle, - static_cast (buf) + bytes_transferred, - len - bytes_transferred); - - // Check for errors. - if (n == 0 || - n == -1) - { - // Check for possible blocking. - if (n == -1 && - errno == EWOULDBLOCK) - { - // Wait upto for the blocking to subside. - int const rtn = ACE::handle_read_ready (handle, timeout); - - // Did select() succeed? - if (rtn != -1) - { - // Blocking subsided in period. Continue - // data transfer. - n = 0; - continue; - } - } - - // Wait in select() timed out or other data transfer or - // select() failures. - error = 1; - result = n; - break; - } - } - - ACE::restore_non_blocking_mode (handle, val); - - if (error) - return result; - else - return static_cast (bytes_transferred); -} - -// This is basically an interface to ACE_OS::readv, that doesn't use -// the struct iovec explicitly. The ... can be passed as an arbitrary -// number of (char *ptr, int len) tuples. However, the count N is the -// *total* number of trailing arguments, *not* a couple of the number -// of tuple pairs! -#if !defined (ACE_LACKS_VA_FUNCTIONS) -ssize_t -ACE::recv (ACE_HANDLE handle, size_t n, ...) -{ - va_list argp; - int const total_tuples = static_cast (n / 2); - iovec *iovp = 0; -#if defined (ACE_HAS_ALLOCA) - iovp = (iovec *) alloca (total_tuples * sizeof (iovec)); -#else -# ifdef ACE_HAS_ALLOC_HOOKS - ACE_ALLOCATOR_RETURN (iovp, (iovec *) - ACE_Allocator::instance ()->malloc (total_tuples * - sizeof (iovec)), - -1); -# else - ACE_NEW_RETURN (iovp, - iovec[total_tuples], - -1); -# endif /* ACE_HAS_ALLOC_HOOKS */ -#endif /* !defined (ACE_HAS_ALLOCA) */ - - va_start (argp, n); - - for (int i = 0; i < total_tuples; i++) - { - iovp[i].iov_base = va_arg (argp, char *); - iovp[i].iov_len = va_arg (argp, int); - } - - ssize_t const result = ACE_OS::recvv (handle, iovp, total_tuples); -#if !defined (ACE_HAS_ALLOCA) -# ifdef ACE_HAS_ALLOC_HOOKS - ACE_Allocator::instance ()->free (iovp); -# else - delete [] iovp; -# endif /* ACE_HAS_ALLOC_HOOKS */ -#endif /* !defined (ACE_HAS_ALLOCA) */ - va_end (argp); - return result; -} -#endif /* ACE_LACKS_VA_FUNCTIONS */ - - -ssize_t -ACE::recvv (ACE_HANDLE handle, - iovec *iov, - int iovcnt, - const ACE_Time_Value *timeout) -{ - if (timeout == 0) - return ACE_OS::recvv (handle, iov, iovcnt); - else - { - int val = 0; - if (ACE::enter_recv_timedwait (handle, timeout, val) == -1) - return -1; - else - { - ssize_t bytes_transferred = ACE_OS::recvv (handle, iov, iovcnt); - ACE::restore_non_blocking_mode (handle, val); - return bytes_transferred; - } - } -} - -ssize_t -ACE::recvv_n_i (ACE_HANDLE handle, - iovec *iov, - int iovcnt, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - bytes_transferred = 0; - - for (int s = 0; s < iovcnt; ) - { - // Try to transfer as much of the remaining data as possible. - ssize_t n = ACE_OS::recvv (handle, iov + s, iovcnt - s); - // Check EOF. - if (n == 0) - return 0; - - // Check for other errors. - if (n == -1) - { - // Check for possible blocking. - if (errno == EWOULDBLOCK) - { - // Wait for the blocking to subside. - int const result = ACE::handle_read_ready (handle, 0); - - // Did select() succeed? - if (result != -1) - { - // Blocking subsided. Continue data transfer. - continue; - } - } - - // Other data transfer or select() failures. - return -1; - } - - for (bytes_transferred += n; - s < iovcnt - && n >= static_cast (iov[s].iov_len); - s++) - n -= iov[s].iov_len; - - if (n != 0) - { - char *base = static_cast (iov[s].iov_base); - iov[s].iov_base = base + n; - // This blind cast is safe because n < iov_len, after above loop. - iov[s].iov_len = iov[s].iov_len - static_cast (n); - } - } - - return ACE_Utils::truncate_cast (bytes_transferred); -} - -ssize_t -ACE::recvv_n_i (ACE_HANDLE handle, - iovec *iov, - int iovcnt, - const ACE_Time_Value *timeout, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - bytes_transferred = 0; - ssize_t result = 0; - int error = 0; - - int val = 0; - ACE::record_and_set_non_blocking_mode (handle, val); - - for (int s = 0; s < iovcnt; ) - { - // Try to transfer as much of the remaining data as possible. - // Since the socket is in non-blocking mode, this call will not - // block. - ssize_t n = ACE_OS::recvv (handle, iov + s, iovcnt - s); - - // Check for errors. - if (n == 0 || n == -1) - { - // Check for possible blocking. - if (n == -1 && errno == EWOULDBLOCK) - { - // Wait upto for the blocking to subside. - int const rtn = ACE::handle_read_ready (handle, timeout); - - // Did select() succeed? - if (rtn != -1) - { - // Blocking subsided in period. Continue - // data transfer. - continue; - } - } - - // Wait in select() timed out or other data transfer or - // select() failures. - error = 1; - result = n; - break; - } - - for (bytes_transferred += n; - s < iovcnt - && n >= static_cast (iov[s].iov_len); - s++) - n -= iov[s].iov_len; - - if (n != 0) - { - char *base = reinterpret_cast (iov[s].iov_base); - iov[s].iov_base = base + n; - // This blind cast is safe because n < iov_len, after above loop. - iov[s].iov_len = iov[s].iov_len - static_cast (n); - } - } - - ACE::restore_non_blocking_mode (handle, val); - - if (error) - { - return result; - } - else - { - return ACE_Utils::truncate_cast (bytes_transferred); - } -} - -ssize_t -ACE::recv_n (ACE_HANDLE handle, - ACE_Message_Block *message_block, - const ACE_Time_Value *timeout, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - bytes_transferred = 0; - - iovec iov[ACE_IOV_MAX]; - int iovcnt = 0; - - while (message_block != 0) - { - // Our current message block chain. - const ACE_Message_Block *current_message_block = message_block; - - while (current_message_block != 0) - { - size_t current_message_block_length = - current_message_block->length (); - char *this_rd_ptr = current_message_block->rd_ptr (); - - // Check if this block has any space for incoming data. - while (current_message_block_length > 0) - { - u_long const this_chunk_length = - ACE_Utils::truncate_cast ( - current_message_block_length); - - // Collect the data in the iovec. - iov[iovcnt].iov_base = this_rd_ptr; - iov[iovcnt].iov_len = this_chunk_length; - current_message_block_length -= this_chunk_length; - this_rd_ptr += this_chunk_length; - - // Increment iovec counter. - ++iovcnt; - - // The buffer is full make a OS call. @@ TODO find a way to - // find ACE_IOV_MAX for platforms that do not define it rather - // than simply setting ACE_IOV_MAX to some arbitrary value such - // as 16. - if (iovcnt == ACE_IOV_MAX) - { - size_t current_transfer = 0; - - ssize_t const result = ACE::recvv_n (handle, - iov, - iovcnt, - timeout, - ¤t_transfer); - - // Add to total bytes transferred. - bytes_transferred += current_transfer; - - // Errors. - if (result == -1 || result == 0) - return result; - - // Reset iovec counter. - iovcnt = 0; - } - } - - // Select the next message block in the chain. - current_message_block = current_message_block->cont (); - } - - // Selection of the next message block chain. - message_block = message_block->next (); - } - - // Check for remaining buffers to be sent. This will happen when - // ACE_IOV_MAX is not a multiple of the number of message blocks. - if (iovcnt != 0) - { - size_t current_transfer = 0; - - ssize_t const result = ACE::recvv_n (handle, - iov, - iovcnt, - timeout, - ¤t_transfer); - - // Add to total bytes transferred. - bytes_transferred += current_transfer; - - // Errors. - if (result == -1 || result == 0) - { - return result; - } - } - - // Return total bytes transferred. - return ACE_Utils::truncate_cast (bytes_transferred); -} - -ssize_t -ACE::send (ACE_HANDLE handle, - const void *buf, - size_t n, - int flags, - const ACE_Time_Value *timeout) -{ - if (timeout == 0) - return ACE_OS::send (handle, (const char *) buf, n, flags); - else - { - int val = 0; - if (ACE::enter_send_timedwait (handle, timeout, val) == -1) - return -1; - else - { - ssize_t const bytes_transferred = - ACE_OS::send (handle, (const char *) buf, n, flags); - ACE::restore_non_blocking_mode (handle, val); - return bytes_transferred; - } - } -} - -#if defined (ACE_HAS_TLI) - -ssize_t -ACE::t_snd (ACE_HANDLE handle, - const void *buf, - size_t n, - int flags, - const ACE_Time_Value *timeout) -{ - if (timeout == 0) - return ACE_OS::t_snd (handle, (const char *) buf, n, flags); - else - { - int val = 0; - if (ACE::enter_send_timedwait (handle, timeout, val) == -1) - return -1; - else - { - ssize_t const bytes_transferred = - ACE_OS::t_snd (handle, (const char *) buf, n, flags); - ACE::restore_non_blocking_mode (handle, val); - return bytes_transferred; - } - } -} - -#endif /* ACE_HAS_TLI */ - -ssize_t -ACE::send (ACE_HANDLE handle, - const void *buf, - size_t n, - const ACE_Time_Value *timeout) -{ - if (timeout == 0) - return ACE::send_i (handle, buf, n); - else - { - int val = 0; - if (ACE::enter_send_timedwait (handle, timeout, val) == -1) - return -1; - else - { - ssize_t const bytes_transferred = ACE::send_i (handle, buf, n); - ACE::restore_non_blocking_mode (handle, val); - return bytes_transferred; - } - } -} - -ssize_t -ACE::sendmsg (ACE_HANDLE handle, - const struct msghdr *msg, - int flags, - const ACE_Time_Value *timeout) -{ - if (timeout == 0) - return ACE_OS::sendmsg (handle, msg, flags); - else - { - int val = 0; - if (ACE::enter_send_timedwait (handle, timeout, val) == -1) - return -1; - else - { - ssize_t const bytes_transferred = - ACE_OS::sendmsg (handle, msg, flags); - ACE::restore_non_blocking_mode (handle, val); - return bytes_transferred; - } - } -} - -ssize_t -ACE::sendto (ACE_HANDLE handle, - const char *buf, - int len, - int flags, - const struct sockaddr *addr, - int addrlen, - const ACE_Time_Value *timeout) -{ - if (timeout == 0) - return ACE_OS::sendto (handle, buf, len, flags, addr, addrlen); - else - { - int val = 0; - if (ACE::enter_send_timedwait (handle, timeout, val) == -1) - return -1; - else - { - ssize_t const bytes_transferred = - ACE_OS::sendto (handle, buf, len, flags, addr, addrlen); - ACE::restore_non_blocking_mode (handle, val); - return bytes_transferred; - } - } -} - -ssize_t -ACE::send_n_i (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - ssize_t n; - - for (bytes_transferred = 0; - bytes_transferred < len; - bytes_transferred += n) - { - // Try to transfer as much of the remaining data as possible. - n = ACE_OS::send (handle, - (char *) buf + bytes_transferred, - len - bytes_transferred, - flags); - // Check EOF. - if (n == 0) - return 0; - - // Check for other errors. - if (n == -1) - { - // Check for possible blocking. -#if defined (ACE_WIN32) - if (errno == EWOULDBLOCK) // If enobufs no need to loop -#else - if (errno == EWOULDBLOCK || errno == ENOBUFS) -#endif /* ACE_WIN32 */ - { - // Wait for the blocking to subside. - int const result = ACE::handle_write_ready (handle, 0); - - // Did select() succeed? - if (result != -1) - { - // Blocking subsided. Continue data transfer. - n = 0; - continue; - } - } - - // Other data transfer or select() failures. - return -1; - } - } - - return ACE_Utils::truncate_cast (bytes_transferred); -} - -ssize_t -ACE::send_n_i (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - ssize_t n; - ssize_t result = 0; - int error = 0; - - int val = 0; - ACE::record_and_set_non_blocking_mode (handle, val); - - for (bytes_transferred = 0; - bytes_transferred < len; - bytes_transferred += n) - { - // Try to transfer as much of the remaining data as possible. - // Since the socket is in non-blocking mode, this call will not - // block. - n = ACE_OS::send (handle, - (char *) buf + bytes_transferred, - len - bytes_transferred, - flags); - - // Check for errors. - if (n == 0 || - n == -1) - { - // Check for possible blocking. - if (n == -1 && (errno == EWOULDBLOCK || errno == ENOBUFS)) - { - // Wait upto for the blocking to subside. - int const rtn = ACE::handle_write_ready (handle, timeout); - - // Did select() succeed? - if (rtn != -1) - { - // Blocking subsided in period. Continue - // data transfer. - n = 0; - continue; - } - } - - // Wait in select() timed out or other data transfer or - // select() failures. - error = 1; - result = n; - break; - } - } - - ACE::restore_non_blocking_mode (handle, val); - - if (error) - { - return result; - } - else - { - return ACE_Utils::truncate_cast (bytes_transferred); - } -} - -#if defined (ACE_HAS_TLI) - -ssize_t -ACE::t_snd_n_i (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - ssize_t n; - - for (bytes_transferred = 0; - bytes_transferred < len; - bytes_transferred += n) - { - // Try to transfer as much of the remaining data as possible. - n = ACE_OS::t_snd (handle, - (char *) buf + bytes_transferred, - len - bytes_transferred, - flags); - // Check EOF. - if (n == 0) - return 0; - - // Check for other errors. - if (n == -1) - { - // Check for possible blocking. - if (errno == EWOULDBLOCK || errno == ENOBUFS) - { - // Wait for the blocking to subside. - int const result = ACE::handle_write_ready (handle, 0); - - // Did select() succeed? - if (result != -1) - { - // Blocking subsided. Continue data transfer. - n = 0; - continue; - } - } - - // Other data transfer or select() failures. - return -1; - } - } - - return bytes_transferred; -} - -ssize_t -ACE::t_snd_n_i (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - ssize_t n; - ssize_t result = 0; - int error = 0; - - int val = 0; - ACE::record_and_set_non_blocking_mode (handle, val); - - for (bytes_transferred = 0; - bytes_transferred < len; - bytes_transferred += n) - { - // Try to transfer as much of the remaining data as possible. - // Since the socket is in non-blocking mode, this call will not - // block. - n = ACE_OS::t_snd (handle, - (char *) buf + bytes_transferred, - len - bytes_transferred, - flags); - - // Check for errors. - if (n == 0 || - n == -1) - { - // Check for possible blocking. - if (n == -1 && - (errno == EWOULDBLOCK || errno == ENOBUFS)) - { - // Wait upto for the blocking to subside. - int const rtn = ACE::handle_write_ready (handle, timeout); - - // Did select() succeed? - if (rtn != -1) - { - // Blocking subsided in period. Continue - // data transfer. - n = 0; - continue; - } - } - - // Wait in select() timed out or other data transfer or - // select() failures. - error = 1; - result = n; - break; - } - } - - ACE::restore_non_blocking_mode (handle, val); - - if (error) - return result; - else - return bytes_transferred; -} - -#endif /* ACE_HAS_TLI */ - -ssize_t -ACE::send_n_i (ACE_HANDLE handle, - const void *buf, - size_t len, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - ssize_t n; - - for (bytes_transferred = 0; - bytes_transferred < len; - bytes_transferred += n) - { - // Try to transfer as much of the remaining data as possible. - n = ACE::send_i (handle, - (char *) buf + bytes_transferred, - len - bytes_transferred); - // Check EOF. - if (n == 0) - { - return 0; - } - - // Check for other errors. - if (n == -1) - { - // Check for possible blocking. - if (errno == EWOULDBLOCK || errno == ENOBUFS) - { - // Wait for the blocking to subside. - int const result = ACE::handle_write_ready (handle, 0); - - // Did select() succeed? - if (result != -1) - { - // Blocking subsided. Continue data transfer. - n = 0; - continue; - } - } - - // Other data transfer or select() failures. - return -1; - } - } - - return ACE_Utils::truncate_cast (bytes_transferred); -} - -ssize_t -ACE::send_n_i (ACE_HANDLE handle, - const void *buf, - size_t len, - const ACE_Time_Value *timeout, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - ssize_t n; - ssize_t result = 0; - int error = 0; - - int val = 0; - ACE::record_and_set_non_blocking_mode (handle, val); - - for (bytes_transferred = 0; - bytes_transferred < len; - bytes_transferred += n) - { - // Try to transfer as much of the remaining data as possible. - // Since the socket is in non-blocking mode, this call will not - // block. - n = ACE::send_i (handle, - (char *) buf + bytes_transferred, - len - bytes_transferred); - - // Check for errors. - if (n == 0 || - n == -1) - { - // Check for possible blocking. - if (n == -1 && - (errno == EWOULDBLOCK || errno == ENOBUFS)) - { - // Wait upto for the blocking to subside. - int const rtn = ACE::handle_write_ready (handle, timeout); - - // Did select() succeed? - if (rtn != -1) - { - // Blocking subsided in period. Continue - // data transfer. - n = 0; - continue; - } - } - - // Wait in select() timed out or other data transfer or - // select() failures. - error = 1; - result = n; - break; - } - } - - ACE::restore_non_blocking_mode (handle, val); - - if (error) - { - return result; - } - else - { - return ACE_Utils::truncate_cast (bytes_transferred); - } -} - -// Send N char *ptrs and int lengths. Note that the char *'s precede -// the ints (basically, an varargs version of writev). The count N is -// the *total* number of trailing arguments, *not* a couple of the -// number of tuple pairs! -#if !defined (ACE_LACKS_VA_FUNCTIONS) -ssize_t -ACE::send (ACE_HANDLE handle, size_t n, ...) -{ - va_list argp; - int total_tuples = static_cast (n / 2); - iovec *iovp; -#if defined (ACE_HAS_ALLOCA) - iovp = (iovec *) alloca (total_tuples * sizeof (iovec)); -#else -# ifdef ACE_HAS_ALLOC_HOOKS - ACE_ALLOCATOR_RETURN (iovp, (iovec *) - ACE_Allocator::instance ()->malloc (total_tuples * - sizeof (iovec)), - -1); -# else - ACE_NEW_RETURN (iovp, - iovec[total_tuples], - -1); -# endif /* ACE_HAS_ALLOC_HOOKS */ -#endif /* !defined (ACE_HAS_ALLOCA) */ - - va_start (argp, n); - - for (int i = 0; i < total_tuples; i++) - { - iovp[i].iov_base = va_arg (argp, char *); - iovp[i].iov_len = va_arg (argp, int); - } - - ssize_t result = ACE_OS::sendv (handle, iovp, total_tuples); -#if !defined (ACE_HAS_ALLOCA) -# ifdef ACE_HAS_ALLOC_HOOKS - ACE_Allocator::instance ()->free (iovp); -# else - delete [] iovp; -# endif /* ACE_HAS_ALLOC_HOOKS */ -#endif /* !defined (ACE_HAS_ALLOCA) */ - va_end (argp); - return result; -} -#endif /* ACE_LACKS_VA_FUNCTIONS */ - -ssize_t -ACE::sendv (ACE_HANDLE handle, - const iovec *iov, - int iovcnt, - const ACE_Time_Value *timeout) -{ - if (timeout == 0) - return ACE_OS::sendv (handle, iov, iovcnt); - else - { - int val = 0; - if (ACE::enter_send_timedwait (handle, timeout, val) == -1) - return -1; - else - { - ssize_t bytes_transferred = ACE_OS::sendv (handle, iov, iovcnt); - ACE::restore_non_blocking_mode (handle, val); - return bytes_transferred; - } - } -} - -ssize_t -ACE::sendv_n_i (ACE_HANDLE handle, - const iovec *i, - int iovcnt, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - bytes_transferred = 0; - - iovec *iov = const_cast (i); - - for (int s = 0; - s < iovcnt; - ) - { - // Try to transfer as much of the remaining data as possible. - ssize_t n = ACE_OS::sendv (handle, iov + s, iovcnt - s); - - // Check EOF. - if (n == 0) - return 0; - - // Check for other errors. - if (n == -1) - { - // Check for possible blocking. - if (errno == EWOULDBLOCK || errno == ENOBUFS) - { - // Wait for the blocking to subside. - int const result = ACE::handle_write_ready (handle, 0); - - // Did select() succeed? - if (result != -1) - { - // Blocking subsided. Continue data transfer. - continue; - } - } - - // Other data transfer or select() failures. - return -1; - } - - for (bytes_transferred += n; - s < iovcnt - && n >= static_cast (iov[s].iov_len); - s++) - n -= iov[s].iov_len; - - if (n != 0) - { - char *base = reinterpret_cast (iov[s].iov_base); - iov[s].iov_base = base + n; - // This blind cast is safe because n < iov_len, after above loop. - iov[s].iov_len = iov[s].iov_len - static_cast (n); - } - } - - return ACE_Utils::truncate_cast (bytes_transferred); -} - -ssize_t -ACE::sendv_n_i (ACE_HANDLE handle, - const iovec *i, - int iovcnt, - const ACE_Time_Value *timeout, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - bytes_transferred = 0; - ssize_t result = 0; - int error = 0; - - int val = 0; - ACE::record_and_set_non_blocking_mode (handle, val); - - iovec *iov = const_cast (i); - - for (int s = 0; - s < iovcnt; - ) - { - // Try to transfer as much of the remaining data as possible. - // Since the socket is in non-blocking mode, this call will not - // block. - ssize_t n = ACE_OS::sendv (handle, iov + s, iovcnt - s); - - // Check for errors. - if (n == 0 || - n == -1) - { - // Check for possible blocking. - if (n == -1 && - (errno == EWOULDBLOCK || errno == ENOBUFS)) - { - // Wait upto for the blocking to subside. - int const rtn = ACE::handle_write_ready (handle, timeout); - - // Did select() succeed? - if (rtn != -1) - { - // Blocking subsided in period. Continue - // data transfer. - continue; - } - } - - // Wait in select() timed out or other data transfer or - // select() failures. - error = 1; - result = n; - break; - } - - for (bytes_transferred += n; - s < iovcnt - && n >= static_cast (iov[s].iov_len); - s++) - n -= iov[s].iov_len; - - if (n != 0) - { - char *base = reinterpret_cast (iov[s].iov_base); - iov[s].iov_base = base + n; - // This blind cast is safe because n < iov_len, after above loop. - iov[s].iov_len = iov[s].iov_len - static_cast (n); - } - } - - ACE::restore_non_blocking_mode (handle, val); - - if (error) - { - return result; - } - else - { - return ACE_Utils::truncate_cast (bytes_transferred); - } -} - -ssize_t -ACE::write_n (ACE_HANDLE handle, - const ACE_Message_Block *message_block, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - bytes_transferred = 0; - - iovec iov[ACE_IOV_MAX]; - int iovcnt = 0; - - while (message_block != 0) - { - // Our current message block chain. - const ACE_Message_Block *current_message_block = message_block; - - while (current_message_block != 0) - { - size_t current_message_block_length = - current_message_block->length (); - char *this_block_ptr = current_message_block->rd_ptr (); - - // Check if this block has any data to be sent. - while (current_message_block_length > 0) - { - u_long const this_chunk_length = - ACE_Utils::truncate_cast ( - current_message_block_length); - - // Collect the data in the iovec. - iov[iovcnt].iov_base = this_block_ptr; - iov[iovcnt].iov_len = this_chunk_length; - current_message_block_length -= this_chunk_length; - this_block_ptr += this_chunk_length; - - // Increment iovec counter. - ++iovcnt; - - // The buffer is full make a OS call. @@ TODO find a way to - // find ACE_IOV_MAX for platforms that do not define it rather - // than simply setting ACE_IOV_MAX to some arbitrary value such - // as 16. - if (iovcnt == ACE_IOV_MAX) - { - size_t current_transfer = 0; - - ssize_t const result = ACE::writev_n (handle, - iov, - iovcnt, - ¤t_transfer); - - // Add to total bytes transferred. - bytes_transferred += current_transfer; - - // Errors. - if (result == -1 || result == 0) - return result; - - // Reset iovec counter. - iovcnt = 0; - } - } - - // Select the next message block in the chain. - current_message_block = current_message_block->cont (); - } - - // Selection of the next message block chain. - message_block = message_block->next (); - } - - // Check for remaining buffers to be sent. This will happen when - // ACE_IOV_MAX is not a multiple of the number of message blocks. - if (iovcnt != 0) - { - size_t current_transfer = 0; - - ssize_t const result = ACE::writev_n (handle, - iov, - iovcnt, - ¤t_transfer); - - // Add to total bytes transferred. - bytes_transferred += current_transfer; - - // Errors. - if (result == -1 || result == 0) - return result; - } - - // Return total bytes transferred. - return ACE_Utils::truncate_cast (bytes_transferred); -} - -ssize_t -ACE::send_n (ACE_HANDLE handle, - const ACE_Message_Block *message_block, - const ACE_Time_Value *timeout, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - bytes_transferred = 0; - - iovec iov[ACE_IOV_MAX]; - int iovcnt = 0; - - while (message_block != 0) - { - // Our current message block chain. - const ACE_Message_Block *current_message_block = message_block; - - while (current_message_block != 0) - { - char *this_block_ptr = current_message_block->rd_ptr (); - size_t current_message_block_length = - current_message_block->length (); - - // Check if this block has any data to be sent. - while (current_message_block_length > 0) - { - u_long const this_chunk_length = - ACE_Utils::truncate_cast ( - current_message_block_length); - - // Collect the data in the iovec. - iov[iovcnt].iov_base = this_block_ptr; - iov[iovcnt].iov_len = this_chunk_length; - current_message_block_length -= this_chunk_length; - this_block_ptr += this_chunk_length; - - // Increment iovec counter. - ++iovcnt; - - // The buffer is full make a OS call. @@ TODO find a way to - // find ACE_IOV_MAX for platforms that do not define it rather - // than simply setting ACE_IOV_MAX to some arbitrary value such - // as 16. - if (iovcnt == ACE_IOV_MAX) - { - size_t current_transfer = 0; - - ssize_t const result = ACE::sendv_n (handle, - iov, - iovcnt, - timeout, - ¤t_transfer); - - // Add to total bytes transferred. - bytes_transferred += current_transfer; - - // Errors. - if (result == -1 || result == 0) - return result; - - // Reset iovec counter. - iovcnt = 0; - } - } - - // Select the next message block in the chain. - current_message_block = current_message_block->cont (); - } - - // Selection of the next message block chain. - message_block = message_block->next (); - } - - // Check for remaining buffers to be sent. This will happen when - // ACE_IOV_MAX is not a multiple of the number of message blocks. - if (iovcnt != 0) - { - size_t current_transfer = 0; - - ssize_t const result = ACE::sendv_n (handle, - iov, - iovcnt, - timeout, - ¤t_transfer); - - // Add to total bytes transferred. - bytes_transferred += current_transfer; - - // Errors. - if (result == -1 || result == 0) - { - return result; - } - } - - // Return total bytes transferred. - return ACE_Utils::truncate_cast (bytes_transferred); -} - -ssize_t -ACE::readv_n (ACE_HANDLE handle, - iovec *iov, - int iovcnt, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - bytes_transferred = 0; - - for (int s = 0; - s < iovcnt; - ) - { - ssize_t n = ACE_OS::readv (handle, - iov + s, - iovcnt - s); - - if (n == -1 || n == 0) - return n; - - for (bytes_transferred += n; - s < iovcnt - && n >= static_cast (iov[s].iov_len); - s++) - n -= iov[s].iov_len; - - if (n != 0) - { - char *base = reinterpret_cast (iov[s].iov_base); - iov[s].iov_base = base + n; - // This blind cast is safe because n < iov_len, after above loop. - iov[s].iov_len = iov[s].iov_len - static_cast (n); - } - } - - return ACE_Utils::truncate_cast (bytes_transferred); -} - -ssize_t -ACE::writev_n (ACE_HANDLE handle, - const iovec *i, - int iovcnt, - size_t *bt) -{ - size_t temp; - size_t &bytes_transferred = bt == 0 ? temp : *bt; - bytes_transferred = 0; - - iovec *iov = const_cast (i); - - for (int s = 0; - s < iovcnt; - ) - { - ssize_t n = ACE_OS::writev (handle, - iov + s, - iovcnt - s); - - if (n == -1 || n == 0) - { - return n; - } - - for (bytes_transferred += n; - s < iovcnt - && n >= static_cast (iov[s].iov_len); - s++) - n -= iov[s].iov_len; - - if (n != 0) - { - char *base = reinterpret_cast (iov[s].iov_base); - iov[s].iov_base = base + n; - // This blind cast is safe because n < iov_len, after above loop. - iov[s].iov_len = iov[s].iov_len - static_cast (n); - } - } - - return ACE_Utils::truncate_cast (bytes_transferred); -} - -int -ACE::handle_ready (ACE_HANDLE handle, - const ACE_Time_Value *timeout, - bool read_ready, - bool write_ready, - bool exception_ready) -{ -#if defined (ACE_HAS_POLL) - ACE_UNUSED_ARG (exception_ready); - - struct pollfd fds; - - fds.fd = handle; - fds.events = read_ready ? POLLIN : 0; - - if( write_ready ) - { - fds.events |= POLLOUT; - } - - fds.revents = 0; - - int const result = ACE_OS::poll (&fds, 1, timeout); -#else - ACE_Handle_Set handle_set; - handle_set.set_bit (handle); - - // Wait for data or for the timeout to elapse. - int select_width = 0; -#if !defined (ACE_WIN32) - select_width = int (handle) + 1; -# endif /* ACE_WIN64 */ - int result = ACE_OS::select (select_width, - read_ready ? handle_set.fdset () : 0, // read_fds. - write_ready ? handle_set.fdset () : 0, // write_fds. - exception_ready ? handle_set.fdset () : 0, // exception_fds. - timeout); - -#endif /* ACE_HAS_POLL */ - switch (result) - { - case 0: // Timer expired. - errno = ETIME; - /* FALLTHRU */ - case -1: // we got here directly - select() returned -1. - return -1; - case 1: // Handle has data. - /* FALLTHRU */ - default: // default is case result > 0; return a - // ACE_ASSERT (result == 1); - return result; - } -} - -int -ACE::enter_recv_timedwait (ACE_HANDLE handle, - const ACE_Time_Value *timeout, - int &val) -{ - int const result = ACE::handle_read_ready (handle, timeout); - - if (result == -1) - return -1; - - ACE::record_and_set_non_blocking_mode (handle, val); - - return result; -} - -int -ACE::enter_send_timedwait (ACE_HANDLE handle, - const ACE_Time_Value *timeout, - int &val) -{ - int const result = ACE::handle_write_ready (handle, timeout); - - if (result == -1) - return -1; - - ACE::record_and_set_non_blocking_mode (handle, val); - - return result; -} - -void -ACE::record_and_set_non_blocking_mode (ACE_HANDLE handle, int &val) -{ - // We need to record whether we are already *in* nonblocking mode, - // so that we can correctly reset the state when we're done. - val = ACE::get_flags (handle); - - if (ACE_BIT_DISABLED (val, ACE_NONBLOCK)) - // Set the handle into non-blocking mode if it's not already in - // it. - ACE::set_flags (handle, ACE_NONBLOCK); -} - -void -ACE::restore_non_blocking_mode (ACE_HANDLE handle, int val) -{ - if (ACE_BIT_DISABLED (val, ACE_NONBLOCK)) - { - // Save/restore errno. - ACE_Errno_Guard error (errno); - // Only disable ACE_NONBLOCK if we weren't in non-blocking mode - // originally. - ACE::clr_flags (handle, ACE_NONBLOCK); - } -} - -/// Format buffer into printable format. This is useful for debugging. -/// Portions taken from mdump by J.P. Knight (J.P.Knight@lut.ac.uk) -/// Modifications by Todd Montgomery. -size_t -ACE::format_hexdump (const char *buffer, - size_t size, - ACE_TCHAR *obuf, - size_t obuf_sz) -{ - ACE_TRACE ("ACE::format_hexdump"); - - u_char c; - ACE_TCHAR textver[16 + 1]; - - // We can fit 16 bytes output in text mode per line, 4 chars per byte. - size_t maxlen = (obuf_sz / 68) * 16; - const ACE_TCHAR *const obuf_start = obuf; - - if (size > maxlen) - size = maxlen; - - size_t i; - - size_t const lines = size / 16; - for (i = 0; i < lines; i++) - { - size_t j; - - for (j = 0 ; j < 16; j++) - { - c = (u_char) buffer[(i << 4) + j]; // or, buffer[i*16+j] - ACE_OS::snprintf (obuf, obuf_sz - (obuf - obuf_start), - ACE_TEXT ("%02x "), - c); - obuf += 3; - if (j == 7) - { - *obuf++ = ACE_TEXT (' '); - } - textver[j] = ACE_OS::ace_isprint (c) ? c : u_char ('.'); - } - - textver[j] = 0; - - ACE_OS::snprintf (obuf, obuf_sz - (obuf - obuf_start), -#if !defined (ACE_WIN32) && defined (ACE_USES_WCHAR) - ACE_TEXT (" %ls\n"), -#else - ACE_TEXT (" %s\n"), -#endif - textver); - - while (*obuf != '\0') - ++obuf; - } - - if (size % 16) - { - for (i = 0 ; i < size % 16; i++) - { - c = (u_char) buffer[size - size % 16 + i]; - ACE_OS::snprintf (obuf, obuf_sz - (obuf - obuf_start), - ACE_TEXT ("%02x "), - c); - obuf += 3; - if (i == 7) - { - *obuf++ = ACE_TEXT (' '); - } - textver[i] = ACE_OS::ace_isprint (c) ? c : u_char ('.'); - } - - for (i = size % 16; i < 16; i++) - { - ACE_OS::snprintf (obuf, obuf_sz - (obuf - obuf_start), - ACE_TEXT (" ")); - obuf += 3; - if (i == 7) - { - *obuf++ = ACE_TEXT (' '); - } - textver[i] = ' '; - } - - textver[i] = 0; - ACE_OS::snprintf (obuf, obuf_sz - (obuf - obuf_start), -#if !defined (ACE_WIN32) && defined (ACE_USES_WCHAR) - ACE_TEXT (" %ls\n"), -#else - ACE_TEXT (" %s\n"), -#endif - textver); - } - return size; -} - -/// Returns the current timestamp in the form -/// "hour:minute:second:microsecond." The month, day, and year are -/// also stored in the beginning of the date_and_time array -/// using ISO-8601 format. -ACE_TCHAR * -ACE::timestamp (ACE_TCHAR date_and_time[], - size_t date_and_timelen, - bool return_pointer_to_first_digit) -{ - return ACE::timestamp (ACE_Time_Value::zero, - date_and_time, - date_and_timelen, - return_pointer_to_first_digit); -} - -/// Returns the given timestamp in the form -/// "hour:minute:second:microsecond." The month, day, and year are -/// also stored in the beginning of the date_and_time array -/// using ISO-8601 format. -/// 012345678901234567890123456 -/// 2010-12-02 12:56:00.123456 -ACE_TCHAR * -ACE::timestamp (const ACE_Time_Value& time_value, - ACE_TCHAR date_and_time[], - size_t date_and_timelen, - bool return_pointer_to_first_digit) -{ - //ACE_TRACE ("ACE::timestamp"); - - // This magic number is from the formatting statement - // farther down this routine. - if (date_and_timelen < 27) - { - errno = EINVAL; - return 0; - } - - ACE_Time_Value cur_time = - (time_value == ACE_Time_Value::zero) ? - ACE_Time_Value (ACE_OS::gettimeofday ()) : time_value; - time_t secs = cur_time.sec (); - struct tm tms; - ACE_OS::localtime_r (&secs, &tms); - ACE_OS::snprintf (date_and_time, - date_and_timelen, - ACE_TEXT ("%4.4d-%2.2d-%2.2d %2.2d:%2.2d:%2.2d.%06ld"), - tms.tm_year + 1900, - tms.tm_mon + 1, - tms.tm_mday, - tms.tm_hour, - tms.tm_min, - tms.tm_sec, - static_cast (cur_time.usec())); - date_and_time[date_and_timelen - 1] = '\0'; - return &date_and_time[10 + (return_pointer_to_first_digit != 0)]; -} - -/// This function rounds the request to a multiple of the page size. -size_t -ACE::round_to_pagesize (size_t len) -{ - ACE_TRACE ("ACE::round_to_pagesize"); - - if (ACE::pagesize_ == 0) - ACE::pagesize_ = ACE_OS::getpagesize (); - - return (len + (ACE::pagesize_ - 1)) & ~(ACE::pagesize_ - 1); -} - -size_t -ACE::round_to_allocation_granularity (size_t len) -{ - ACE_TRACE ("ACE::round_to_allocation_granularity"); - - if (ACE::allocation_granularity_ == 0) - ACE::allocation_granularity_ = ACE_OS::allocation_granularity (); - - return (len + (ACE::allocation_granularity_ - 1)) & ~(ACE::allocation_granularity_ - 1); -} - -ACE_HANDLE -ACE::handle_timed_complete (ACE_HANDLE h, - const ACE_Time_Value *timeout, - int is_tli) -{ - ACE_TRACE ("ACE::handle_timed_complete"); - -#if !defined (ACE_WIN32) && defined (ACE_HAS_POLL) - - struct pollfd fds; - - fds.fd = h; - fds.events = POLLIN | POLLOUT; - fds.revents = 0; - -#else - ACE_Handle_Set rd_handles; - ACE_Handle_Set wr_handles; - rd_handles.set_bit (h); - wr_handles.set_bit (h); -#endif /* !ACE_WIN32 && ACE_HAS_POLL */ - -#if defined (ACE_WIN32) - // Winsock is different - it sets the exception bit for failed connect, - // unlike other platforms, where the write bit is set for both success - // and fail. - ACE_Handle_Set ex_handles; - ex_handles.set_bit (h); -#endif /* ACE_WIN32 */ - - bool need_to_check = false; - bool known_failure = false; - -#if defined (ACE_WIN32) - int n = ACE_OS::select (0, // Ignored on Windows: int (h) + 1, - 0, - wr_handles, - ex_handles, - timeout); -#else -# if defined (ACE_HAS_POLL) - - int n = ACE_OS::poll (&fds, 1, timeout); - -# else - int n = 0; - if (is_tli) - n = ACE_OS::select (int (h) + 1, - rd_handles, - wr_handles, - 0, - timeout); - else - n = ACE_OS::select (int (h) + 1, - 0, - wr_handles, - 0, - timeout); -# endif /* ACE_HAS_POLL */ -#endif /* ACE_WIN32 */ - - // If we failed to connect within the time period allocated by the - // caller, then we fail (e.g., the remote host might have been too - // busy to accept our call). - if (n <= 0) - { - if (n == 0 && timeout != 0) - errno = ETIME; - return ACE_INVALID_HANDLE; - } - - // On Windows, a ready-for-write handle is successfully connected, and - // ready-for-exception is a failure. On fails, we need to grab the error - // code via getsockopt. - // On BSD sockets using select(), the handle becomes writable on - // completion either success or fail, so if the select() does not time - // out, we need to check for success/fail. - // It is believed that TLI sockets use the readable=fail, writeable=success - // but that hasn't been as well tested. -#if defined (ACE_WIN32) - ACE_UNUSED_ARG (is_tli); - - // On Win32, ex_handle set indicates a failure. We'll do the check - // to try and get an errno value, but the connect failed regardless of - // what getsockopt says about the error. - if (ex_handles.is_set (h)) - { - need_to_check = true; - known_failure = true; - } -#else - if (is_tli) -# if defined (ACE_HAS_POLL) - need_to_check = (fds.revents & POLLIN) && !(fds.revents & POLLOUT); -# else - need_to_check = rd_handles.is_set (h) && !wr_handles.is_set (h); -# endif /* ACE_HAS_POLL */ - - else -# if defined (ACE_HAS_POLL) - { - // The "official" bit for failed connect is POLLIN. However, POLLERR - // is often set and there are occasional cases seen with some kernels - // where only POLLERR is set on a failed connect. - need_to_check = (fds.revents & POLLIN) || (fds.revents & POLLERR); - known_failure = (fds.revents & POLLERR); - } -# else - need_to_check = true; -# endif /* ACE_HAS_POLL */ -#endif /* ACE_WIN32 */ - - if (need_to_check) - { -#if defined (SOL_SOCKET) && defined (SO_ERROR) - int sock_err = 0; - int sock_err_len = sizeof (sock_err); - int sockopt_ret = ACE_OS::getsockopt (h, SOL_SOCKET, SO_ERROR, - (char *)&sock_err, &sock_err_len); - if (sockopt_ret < 0) - { - h = ACE_INVALID_HANDLE; - } - - if (sock_err != 0 || known_failure) - { - h = ACE_INVALID_HANDLE; - errno = sock_err; - } -#else - char dummy; - - // The following recv() won't block provided that the - // ACE_NONBLOCK flag has not been turned off . - n = ACE::recv (h, &dummy, 1, MSG_PEEK); - - // If no data was read/peeked at, check to see if it's because - // of a non-connected socket (and therefore an error) or there's - // just no data yet. - if (n <= 0) - { - if (n == 0) - { - errno = ECONNREFUSED; - h = ACE_INVALID_HANDLE; - } - else if (errno != EWOULDBLOCK && errno != EAGAIN) - h = ACE_INVALID_HANDLE; - } -#endif - } - - // 1. The HANDLE is ready for writing and doesn't need to be checked or - // 2. recv() returned an indication of the state of the socket - if there is - // either data present, or a recv is legit but there's no data yet, - // the connection was successfully established. - return h; -} - -/// Wait up to @a timeout amount of time to accept a connection. -int -ACE::handle_timed_accept (ACE_HANDLE listener, - ACE_Time_Value *timeout, - bool restart) -{ - ACE_TRACE ("ACE::handle_timed_accept"); - // Make sure we don't bomb out on erroneous values. - if (listener == ACE_INVALID_HANDLE) - return -1; - -#if defined (ACE_HAS_POLL) - - struct pollfd fds; - - fds.fd = listener; - fds.events = POLLIN; - fds.revents = 0; - -#else - // Use the select() implementation rather than poll(). - ACE_Handle_Set rd_handle; - rd_handle.set_bit (listener); -#endif /* ACE_HAS_POLL */ - - // We need a loop here if is enabled. - - for (;;) - { -#if defined (ACE_HAS_POLL) - - int n = ACE_OS::poll (&fds, 1, timeout); - -#else - int select_width = 0; -# if !defined (ACE_WIN32) - select_width = int (listener) + 1; -# endif /* ACE_WIN32 */ - int n = ACE_OS::select (select_width, - rd_handle, 0, 0, - timeout); -#endif /* ACE_HAS_POLL */ - - switch (n) - { - case -1: - if (errno == EINTR && restart) - continue; - else - return -1; - /* NOTREACHED */ - case 0: - if (timeout != 0 && *timeout == ACE_Time_Value::zero) - errno = EWOULDBLOCK; - else - errno = ETIMEDOUT; - return -1; - /* NOTREACHED */ - case 1: - return 0; - /* NOTREACHED */ - default: - errno = EINVAL; - return -1; - /* NOTREACHED */ - } - } -} - -/// Make the current process a UNIX daemon. This is based on Stevens -/// code from APUE. -int -ACE::daemonize (const ACE_TCHAR pathname[], - bool close_all_handles, - const ACE_TCHAR program_name[]) -{ - ACE_TRACE ("ACE::daemonize"); -#if !defined (ACE_LACKS_FORK) - pid_t pid = ACE_OS::fork (); - - if (pid == -1) - return -1; - else if (pid != 0) - ACE_OS::exit (0); // Parent exits. - - // 1st child continues. - ACE_OS::setsid (); // Become session leader. - - ACE_OS::signal (SIGHUP, SIG_IGN); - - pid = ACE_OS::fork (program_name); - - if (pid != 0) - ACE_OS::exit (0); // First child terminates. - - // Second child continues. - - if (pathname != 0) - // change working directory. - ACE_OS::chdir (pathname); - - ACE_OS::umask (0); // clear our file mode creation mask. - - // Close down the I/O handles. - if (close_all_handles) - { - for (int i = ACE::max_handles () - 1; i >= 0; i--) - ACE_OS::close (i); - - int fd = ACE_OS::open ("/dev/null", O_RDWR, 0); - if (fd != -1) - { - ACE_OS::dup2 (fd, ACE_STDIN); - ACE_OS::dup2 (fd, ACE_STDOUT); - ACE_OS::dup2 (fd, ACE_STDERR); - - if (fd > ACE_STDERR) - ACE_OS::close (fd); - } - } - - return 0; -#else - ACE_UNUSED_ARG (pathname); - ACE_UNUSED_ARG (close_all_handles); - ACE_UNUSED_ARG (program_name); - - ACE_NOTSUP_RETURN (-1); -#endif /* ACE_LACKS_FORK */ -} - -pid_t -ACE::fork (const ACE_TCHAR *program_name, - int avoid_zombies) -{ - if (avoid_zombies == 0) - return ACE_OS::fork (program_name); - else - { - // This algorithm is adapted from an example in the Stevens book - // "Advanced Programming in the Unix Environment" and an item in - // Andrew Gierth's Unix Programming FAQ. It creates an orphan - // process that's inherited by the init process; init cleans up - // when the orphan process terminates. - // - // Another way to avoid zombies is to ignore or catch the - // SIGCHLD signal; we don't use that approach here. - - pid_t pid = ACE_OS::fork (); - if (pid == 0) - { - // The child process forks again to create a grandchild. - switch (ACE_OS::fork (program_name)) - { - case 0: // grandchild returns 0. - return 0; - case static_cast(-1): // assumes all errnos are < 256 - ACE_OS::_exit (errno); - default: // child terminates, orphaning grandchild - ACE_OS::_exit (0); - } - } - - // Parent process waits for child to terminate. - ACE_exitcode status; - if (pid < 0 || ACE_OS::waitpid (pid, &status, 0) < 0) - return -1; - - // child terminated by calling exit()? - if (WIFEXITED ((status))) - { - // child terminated normally? - if (WEXITSTATUS ((status)) == 0) - return 1; - else - errno = WEXITSTATUS ((status)); - } - else - // child didn't call exit(); perhaps it received a signal? - errno = EINTR; - - return -1; - } -} - -int -ACE::max_handles (void) -{ - ACE_TRACE ("ACE::max_handles"); -#if defined (RLIMIT_NOFILE) && !defined (ACE_LACKS_RLIMIT) - rlimit rl; - int const r = ACE_OS::getrlimit (RLIMIT_NOFILE, &rl); -# if !defined (RLIM_INFINITY) - if (r == 0) - return rl.rlim_cur; -# else - if (r == 0 && rl.rlim_cur != RLIM_INFINITY) - return rl.rlim_cur; - // If == RLIM_INFINITY, fall through to the ACE_LACKS_RLIMIT sections -# endif /* RLIM_INFINITY */ -#endif /* RLIMIT_NOFILE && !ACE_LACKS_RLIMIT */ - -#if defined (_SC_OPEN_MAX) && !defined (ACE_LACKS_SYSCONF) - return static_cast (ACE_OS::sysconf (_SC_OPEN_MAX)); -#elif defined (FD_SETSIZE) - return FD_SETSIZE; -#else - ACE_NOTSUP_RETURN (-1); -#endif /* _SC_OPEN_MAX */ -} - -// Set the number of currently open handles in the process. -// -// If NEW_LIMIT == -1 set the limit to the maximum allowable. -// Otherwise, set it to be the value of NEW_LIMIT. - -int -ACE::set_handle_limit (int new_limit, - int increase_limit_only) -{ - ACE_TRACE ("ACE::set_handle_limit"); - int cur_limit = ACE::max_handles (); - int max_limit = cur_limit; - - if (cur_limit == -1) - return -1; - -#if !defined (ACE_LACKS_RLIMIT) && defined (RLIMIT_NOFILE) - struct rlimit rl; - - ACE_OS::memset ((void *) &rl, 0, sizeof rl); - int r = ACE_OS::getrlimit (RLIMIT_NOFILE, &rl); - if (r == 0) - max_limit = rl.rlim_max; -#endif /* ACE_LACKS_RLIMIT */ - - if (new_limit == -1) - new_limit = max_limit; - - if (new_limit < 0) - { - errno = EINVAL; - return -1; - } - else if (new_limit > cur_limit) - { - // Increase the limit. -#if !defined (ACE_LACKS_RLIMIT) && defined (RLIMIT_NOFILE) - rl.rlim_cur = new_limit; - return ACE_OS::setrlimit (RLIMIT_NOFILE, &rl); -#elif !defined (RLIMIT_NOFILE) - return 0; -#else - // Must return EINVAL errno. - ACE_NOTSUP_RETURN (-1); -#endif /* ACE_LACKS_RLIMIT */ - } - else if (increase_limit_only == 0) - { - // Decrease the limit. -#if !defined (ACE_LACKS_RLIMIT) && defined (RLIMIT_NOFILE) - rl.rlim_cur = new_limit; - return ACE_OS::setrlimit (RLIMIT_NOFILE, &rl); -#else - // We give a chance to platforms without RLIMIT to work. - // Instead of ACE_NOTSUP_RETURN (0), just return 0 because - // new_limit is <= cur_limit, so it's a no-op. - return 0; -#endif /* ACE_LACKS_RLIMIT */ - } - - return 0; -} - -/// Euclid's greatest common divisor algorithm. -u_long -ACE::gcd (u_long x, u_long y) -{ - while (y != 0) - { - u_long r = x % y; - x = y; - y = r; - } - - return x; -} - - -/// Calculates the minimum enclosing frame size for the given values. -u_long -ACE::minimum_frame_size (u_long period1, u_long period2) -{ - // if one of the periods is zero, treat it as though it as - // uninitialized and return the other period as the frame size - if (0 == period1) - { - return period2; - } - if (0 == period2) - { - return period1; - } - - // if neither is zero, find the greatest common divisor of the two periods - u_long greatest_common_divisor = ACE::gcd (period1, period2); - - // explicitly consider cases to reduce risk of possible overflow errors - if (greatest_common_divisor == 1) - { - // periods are relative primes: just multiply them together - return period1 * period2; - } - else if (greatest_common_divisor == period1) - { - // the first period divides the second: return the second - return period2; - } - else if (greatest_common_divisor == period2) - { - // the second period divides the first: return the first - return period1; - } - else - { - // the current frame size and the entry's effective period - // have a non-trivial greatest common divisor: return the - // product of factors divided by those in their gcd. - return (period1 * period2) / greatest_common_divisor; - } -} - - -u_long -ACE::is_prime (const u_long n, - const u_long min_factor, - const u_long max_factor) -{ - if (n > 3) - for (u_long factor = min_factor; - factor <= max_factor; - ++factor) - if (n / factor * factor == n) - return factor; - - return 0; -} - -const ACE_TCHAR * -ACE::sock_error (int error) -{ -#if defined (ACE_WIN32) - static ACE_TCHAR unknown_msg[64]; - - switch (error) - { - case WSAVERNOTSUPPORTED: - return ACE_TEXT ("version of WinSock not supported"); - /* NOTREACHED */ - case WSASYSNOTREADY: - return ACE_TEXT ("WinSock not present or not responding"); - /* NOTREACHED */ - case WSAEINVAL: - return ACE_TEXT ("app version not supported by DLL"); - /* NOTREACHED */ - case WSAHOST_NOT_FOUND: - return ACE_TEXT ("Authoritive: Host not found"); - /* NOTREACHED */ - case WSATRY_AGAIN: - return ACE_TEXT ("Non-authoritive: host not found or server failure"); - /* NOTREACHED */ - case WSANO_RECOVERY: - return ACE_TEXT ("Non-recoverable: refused or not implemented"); - /* NOTREACHED */ - case WSANO_DATA: - return ACE_TEXT ("Valid name, no data record for type"); - /* NOTREACHED */ - /* - case WSANO_ADDRESS: - return "Valid name, no MX record"; - */ - case WSANOTINITIALISED: - return ACE_TEXT ("WSA Startup not initialized"); - /* NOTREACHED */ - case WSAENETDOWN: - return ACE_TEXT ("Network subsystem failed"); - /* NOTREACHED */ - case WSAEINPROGRESS: - return ACE_TEXT ("Blocking operation in progress"); - /* NOTREACHED */ - case WSAEINTR: - return ACE_TEXT ("Blocking call cancelled"); - /* NOTREACHED */ - case WSAEAFNOSUPPORT: - return ACE_TEXT ("address family not supported"); - /* NOTREACHED */ - case WSAEMFILE: - return ACE_TEXT ("no file handles available"); - /* NOTREACHED */ - case WSAENOBUFS: - return ACE_TEXT ("no buffer space available"); - /* NOTREACHED */ - case WSAEPROTONOSUPPORT: - return ACE_TEXT ("specified protocol not supported"); - /* NOTREACHED */ - case WSAEPROTOTYPE: - return ACE_TEXT ("protocol wrong type for this socket"); - /* NOTREACHED */ - case WSAESOCKTNOSUPPORT: - return ACE_TEXT ("socket type not supported for address family"); - /* NOTREACHED */ - case WSAENOTSOCK: - return ACE_TEXT ("handle is not a socket"); - /* NOTREACHED */ - case WSAEWOULDBLOCK: - return ACE_TEXT ("resource temporarily unavailable"); - /* NOTREACHED */ - case WSAEADDRINUSE: - return ACE_TEXT ("address already in use"); - /* NOTREACHED */ - case WSAECONNABORTED: - return ACE_TEXT ("connection aborted"); - /* NOTREACHED */ - case WSAECONNRESET: - return ACE_TEXT ("connection reset"); - /* NOTREACHED */ - case WSAENOTCONN: - return ACE_TEXT ("not connected"); - /* NOTREACHED */ - case WSAETIMEDOUT: - return ACE_TEXT ("connection timed out"); - /* NOTREACHED */ - case WSAECONNREFUSED: - return ACE_TEXT ("connection refused"); - /* NOTREACHED */ - case WSAEHOSTDOWN: - return ACE_TEXT ("host down"); - /* NOTREACHED */ - case WSAEHOSTUNREACH: - return ACE_TEXT ("host unreachable"); - /* NOTREACHED */ - case WSAEADDRNOTAVAIL: - return ACE_TEXT ("address not available"); - /* NOTREACHED */ - case WSAEISCONN: - return ACE_TEXT ("socket is already connected"); - /* NOTREACHED */ - case WSAENETRESET: - return ACE_TEXT ("network dropped connection on reset"); - /* NOTREACHED */ - case WSAEMSGSIZE: - return ACE_TEXT ("message too long"); - /* NOTREACHED */ - case WSAENETUNREACH: - return ACE_TEXT ("network is unreachable"); - /* NOTREACHED */ - case WSAEFAULT: - return ACE_TEXT ("bad address"); - /* NOTREACHED */ - case WSAEDISCON: - return ACE_TEXT ("graceful shutdown in progress"); - /* NOTREACHED */ - case WSAEACCES: - return ACE_TEXT ("permission denied"); - /* NOTREACHED */ - case WSAESHUTDOWN: - return ACE_TEXT ("cannot send after socket shutdown"); - /* NOTREACHED */ - case WSAEPROCLIM: - return ACE_TEXT ("too many processes"); - /* NOTREACHED */ - case WSAEALREADY: - return ACE_TEXT ("operation already in progress"); - /* NOTREACHED */ - case WSAEPFNOSUPPORT: - return ACE_TEXT ("protocol family not supported"); - /* NOTREACHED */ - case WSAENOPROTOOPT: - return ACE_TEXT ("bad protocol option"); - /* NOTREACHED */ - case WSATYPE_NOT_FOUND: - return ACE_TEXT ("class type not found"); - /* NOTREACHED */ - case WSAEOPNOTSUPP: - return ACE_TEXT ("operation not supported"); - /* NOTREACHED */ - case WSAEDESTADDRREQ: - return ACE_TEXT ("destination address required"); - /* NOTREACHED */ - default: - ACE_OS::snprintf (unknown_msg, - sizeof unknown_msg / sizeof unknown_msg[0], - ACE_TEXT ("unknown error: %d"), error); - return unknown_msg; - /* NOTREACHED */ - } -#else - ACE_UNUSED_ARG (error); - ACE_NOTSUP_RETURN (0); -#endif /* ACE_WIN32 */ -} - -bool -ACE::is_sock_error (int error) -{ -#if defined (ACE_WIN32) - switch (error) - { - case WSAVERNOTSUPPORTED: - case WSASYSNOTREADY: - case WSAEINVAL: - case WSAHOST_NOT_FOUND: - case WSATRY_AGAIN: - case WSANO_RECOVERY: - case WSANO_DATA: - /* - case WSANO_ADDRESS: - */ - case WSANOTINITIALISED: - case WSAENETDOWN: - case WSAEINPROGRESS: - case WSAEINTR: - case WSAEAFNOSUPPORT: - case WSAEMFILE: - case WSAENOBUFS: - case WSAEPROTONOSUPPORT: - case WSAEPROTOTYPE: - case WSAESOCKTNOSUPPORT: - case WSAENOTSOCK: - case WSAEWOULDBLOCK: - case WSAEADDRINUSE: - case WSAECONNABORTED: - case WSAECONNRESET: - case WSAENOTCONN: - case WSAETIMEDOUT: - case WSAECONNREFUSED: - case WSAEHOSTDOWN: - case WSAEHOSTUNREACH: - case WSAEADDRNOTAVAIL: - case WSAEISCONN: - case WSAENETRESET: - case WSAEMSGSIZE: - case WSAENETUNREACH: - case WSAEFAULT: - case WSAEDISCON: - case WSAEACCES: - case WSAESHUTDOWN: - case WSAEPROCLIM: - case WSAEALREADY: - case WSAEPFNOSUPPORT: - case WSAENOPROTOOPT: - case WSATYPE_NOT_FOUND: - case WSAEOPNOTSUPP: - return true; - } -#else - ACE_UNUSED_ARG (error); -#endif /* ACE_WIN32 */ - return false; -} - -char * -ACE::strndup (const char *str, size_t n) -{ - const char *t = str; - size_t len; - - // Figure out how long this string is (remember, it might not be - // NUL-terminated). - - for (len = 0; - len < n && *t++ != '\0'; - len++) - continue; - - char *s; -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (s, - (char *) ACE_Allocator::instance()->malloc (len + 1), - 0); -#else - ACE_ALLOCATOR_RETURN (s, - (char *) ACE_OS::malloc (len + 1), - 0); -#endif /* ACE_HAS_ALLOC_HOOKS */ - return ACE_OS::strsncpy (s, str, len + 1); -} - -#if defined (ACE_HAS_WCHAR) -wchar_t * -ACE::strndup (const wchar_t *str, size_t n) -{ - const wchar_t *t = str; - size_t len; - - // Figure out how long this string is (remember, it might not be - // NUL-terminated). - - for (len = 0; - len < n && *t++ != '\0'; - len++) - continue; - - size_t const size = (len + 1) * sizeof (wchar_t); - wchar_t *s = 0; -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (s, - static_cast ( - ACE_Allocator::instance ()->malloc (size)), - 0); -#else - ACE_ALLOCATOR_RETURN (s, - static_cast (ACE_OS::malloc (size)), - 0); -#endif /* ACE_HAS_ALLOC_HOOKS */ - return ACE_OS::strsncpy (s, str, len + 1); -} -#endif /* ACE_HAS_WCHAR */ - -char * -ACE::strnnew (const char *str, size_t n) -{ - const char *t = str; - size_t len; - - // Figure out how long this string is (remember, it might not be - // NUL-terminated). - - for (len = 0; - len < n && *t++ != L'\0'; - len++) - continue; - - char *s; - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (s, - static_cast (ACE_Allocator::instance ()->malloc (sizeof (char) * (len + 1))), - 0); -#else - ACE_NEW_RETURN (s, - char[len + 1], - 0); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - return ACE_OS::strsncpy (s, str, len + 1); -} - -#if defined (ACE_HAS_WCHAR) -wchar_t * -ACE::strnnew (const wchar_t *str, size_t n) -{ - const wchar_t *t = str; - size_t len; - - // Figure out how long this string is (remember, it might not be - // NUL-terminated). - - for (len = 0; - len < n && *t++ != ACE_TEXT_WIDE ('\0'); - len++) - continue; - - wchar_t *s; - ACE_NEW_RETURN (s, - wchar_t[len + 1], - 0); - return ACE_OS::strsncpy (s, str, len + 1); -} -#endif /* ACE_HAS_WCHAR */ - -const char * -ACE::strend (const char *s) -{ - while (*s++ != '\0') - continue; - - return s; -} - -#if defined ACE_HAS_WCHAR -const wchar_t * -ACE::strend (const wchar_t *s) -{ - while (*s++ != ACE_TEXT_WIDE ('\0')) - continue; - - return s; -} -#endif - -char * -ACE::strnew (const char *s) -{ - if (s == 0) - return 0; - char *t = 0; -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (t, - static_cast (ACE_Allocator::instance ()->malloc (sizeof (char) * (ACE_OS::strlen (s) + 1))), - 0); -#else - ACE_NEW_RETURN (t, - char [ACE_OS::strlen (s) + 1], - 0); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - return ACE_OS::strcpy (t, s); -} - -#if defined (ACE_HAS_WCHAR) -wchar_t * -ACE::strnew (const wchar_t *s) -{ - if (s == 0) - return 0; - - size_t const n = ACE_OS::strlen (s) + 1; - wchar_t *t = 0; -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (t, - static_cast ( - ACE_Allocator::instance ()->malloc ( - sizeof (wchar_t) * (n))), - 0); -#else - ACE_NEW_RETURN (t, wchar_t[n], 0); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - return ACE_OS::strcpy (t, s); -} -#endif /* ACE_HAS_WCHAR */ - -// helper functions for ACE::wild_match() -namespace -{ - - inline bool equal_char (char a, char b, bool case_sensitive) - { - if (case_sensitive) - return a == b; - return ACE_OS::ace_tolower (a) == ACE_OS::ace_tolower (b); - } - - // precond: *p == '[' start of char class - // postcond: *p == ']' end of the char class - inline bool equal_class (char s, const char *&p, bool case_sensitive) - { - ++p; - bool negate = false; - if (*p == '!') - { - negate = true; - ++p; - } - // ] and - are regular in 1st position - for (bool first = true; *p && (first || *p != ']'); ++p) - { - if (!first && *p == '-' && p[1] != ']') - { - if (!p[1] || p[1] <= p[-1]) // invalid range - { - continue; - } - // Since we are in the POSIX locale, only the basic ASCII - // characters are allowed as the range endpoints. These characters - // are the same values in both signed and unsigned chars so we - // don't have to account for any "pathological cases." - for (char range = static_cast (p[-1] + 1); range <= p[1]; ++range) - { - if (equal_char (s, range, case_sensitive)) - { - while (*++p != ']') {} - return !negate; - } - } - ++p; // consume the character 1 past the - - } - else if (equal_char (s, *p, case_sensitive)) - { - while (*++p != ']') {} - return !negate; - } - first = false; - } - return negate; - } -} - -bool -ACE::wild_match(const char *str, const char *pat, bool case_sensitive, - bool character_classes) -{ - if (str == pat) - return true; - if (pat == 0 || str == 0) - return false; - - bool star = false, escape = false; - const char *s = str; - const char *p = pat; - while (*s != '\0') - { - if (!escape && *p == '\\') - { - ++p; - escape = true; - } - else if (!escape && *p == '*') - { - star = true; - pat = p; - while (*++pat == '*') {} - - if (*pat == '\0') - return true; - p = pat; - } - else if (!escape && *p == '?') - { - ++s; - ++p; - } - else if (!escape && character_classes && *p == '[') - { - if (equal_class (*s, p, case_sensitive)) - { - ++p; - } - else - { - if (!star) - return false; - p = pat; - } - ++s; - } - else if (!equal_char (*s, *p, case_sensitive)) - { - if (!star) - return false; - ++s; - p = pat; - escape = false; - } - else - { - ++s; - ++p; - escape = false; - } - } - if (*p == '*') - while (*++p == '*') {} - - return *p == '\0'; -} - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/ACE.h b/deps/acelite/ace/ACE.h deleted file mode 100644 index d10dc6710..000000000 --- a/deps/acelite/ace/ACE.h +++ /dev/null @@ -1,891 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file ACE.h - * - * This file contains value added ACE functions that extend the - * behavior of the UNIX and Win32 OS calls. - * - * All these ACE static functions are consolidated in a single place - * in order to manage the namespace better. These functions are put - * here rather than in @c ACE_OS in order to separate concerns. - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_ACE_H -#define ACE_ACE_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-lite.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Basic_Types.h" -#include "ace/Default_Constants.h" - -#if defined (ACE_EXPORT_MACRO) -# undef ACE_EXPORT_MACRO -#endif -#define ACE_EXPORT_MACRO ACE_Export - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward declarations. -class ACE_Time_Value; -class ACE_Message_Block; -class ACE_Handle_Set; - -/** - * @namespace ACE - * - * @brief The namespace containing the ACE framework itself. - * - * The ACE namespace contains all types (classes, structures, - * typedefs, etc), and global functions and variables in the ACE - * framework. - */ -namespace ACE -{ - // = ACE version information. - /// e.g., the "6" in ACE 6.3.4 - extern ACE_Export u_int major_version (void); - - /// e.g., the "3" in ACE 6.3.4 - extern ACE_Export u_int minor_version (void); - - /// e.g., the "4" in ACE 6.3.4 - /// Returns 0 for "stable" (non-micro) releases. - extern ACE_Export u_int micro_version (void); - - /// e.g., the "4" in ACE 6.3.4 - /// Returns 0 for "stable" (non-micro) releases. - extern ACE_Export u_int beta_version (void); - - // = C++ compiler version information. - /// E.g., the "SunPro C++" in SunPro C++ 4.32.0 - extern ACE_Export const ACE_TCHAR * compiler_name (void); - - /// E.g., the "4" in SunPro C++ 4.32.0 - extern ACE_Export u_int compiler_major_version (void); - - /// E.g., the "32" in SunPro C++ 4.32.0 - extern ACE_Export u_int compiler_minor_version (void); - - /// E.g., the "0" in SunPro C++ 4.32.0 - extern ACE_Export u_int compiler_beta_version (void); - - /// Check if error indicates the process being out of handles (file - /// descriptors). - extern ACE_Export int out_of_handles (int error); - - /// Simple wildcard matching function supporting '*' and '?' - /// return true if string s matches pattern. - /// If @a character_classes is true, '[' is treated as a wildcard character - /// as described in the fnmatch() POSIX API. The following POSIX "bracket - /// expression" features are not implemented: collating symbols, equivalence - /// class expressions, and character class expressions. The POSIX locale is - /// assumed. - extern ACE_Export bool wild_match(const char* s, const char* pattern, - bool case_sensitive = true, bool character_classes = false); - - /** - * @name I/O operations - * - * Notes on common parameters: - * - * @a handle is the connected endpoint that will be used for I/O. - * - * @a buf is the buffer to write from or receive into. - * - * @a len is the number of bytes to transfer. - * - * The @a timeout parameter in the following methods indicates how - * long to blocking trying to transfer data. If @a timeout == 0, - * then the call behaves as a normal send/recv call, i.e., for - * blocking sockets, the call will block until action is possible; - * for non-blocking sockets, @c EWOULDBLOCK will be returned if no - * action is immediately possible. - * - * If @a timeout != 0, the call will wait until the relative time - * specified in @a *timeout elapses. - * - * The "_n()" I/O methods keep looping until all the data has been - * transferred. These methods also work for sockets in non-blocking - * mode i.e., they keep looping on @c EWOULDBLOCK. @a timeout is - * used to make sure we keep making progress, i.e., the same timeout - * value is used for every I/O operation in the loop and the timeout - * is not counted down. - * - * The return values for the "*_n()" methods match the return values - * from the non "_n()" methods and are specified as follows: - * - * - On complete transfer, the number of bytes transferred is returned. - * - On timeout, -1 is returned, @c errno == @c ETIME. - * - On error, -1 is returned, @c errno is set to appropriate error. - * - On @c EOF, 0 is returned, @c errno is irrelevant. - * - * On partial transfers, i.e., if any data is transferred before - * timeout / error / @c EOF, @a bytes_transferred> will contain the - * number of bytes transferred. - * - * Methods with @a iovec parameter are I/O vector variants of the - * I/O operations. - * - * Methods with the extra @a flags argument will always result in - * @c send getting called. Methods without the extra @a flags - * argument will result in @c send getting called on Win32 - * platforms, and @c write getting called on non-Win32 platforms. - */ - //@{ - extern ACE_Export ssize_t recv (ACE_HANDLE handle, - void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout = 0); - -#if defined (ACE_HAS_TLI) - - extern ACE_Export ssize_t t_rcv (ACE_HANDLE handle, - void *buf, - size_t len, - int *flags, - const ACE_Time_Value *timeout = 0); - -#endif /* ACE_HAS_TLI */ - - extern ACE_Export ssize_t recv (ACE_HANDLE handle, - void *buf, - size_t len, - const ACE_Time_Value *timeout = 0); - - extern ACE_Export ssize_t recvmsg (ACE_HANDLE handle, - struct msghdr *msg, - int flags, - const ACE_Time_Value *timeout = 0); - - extern ACE_Export ssize_t recvfrom (ACE_HANDLE handle, - char *buf, - int len, - int flags, - struct sockaddr *addr, - int *addrlen, - const ACE_Time_Value *timeout = 0); - - ACE_NAMESPACE_INLINE_FUNCTION - ssize_t recv_n (ACE_HANDLE handle, - void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0); - -#if defined (ACE_HAS_TLI) - - ACE_NAMESPACE_INLINE_FUNCTION - ssize_t t_rcv_n (ACE_HANDLE handle, - void *buf, - size_t len, - int *flags, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0); - -#endif /* ACE_HAS_TLI */ - - ACE_NAMESPACE_INLINE_FUNCTION - ssize_t recv_n (ACE_HANDLE handle, - void *buf, - size_t len, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0); - - /// Receive into a variable number of pieces. - /** - * Accepts a variable, caller-specified, number of pointer/length - * pairs. Arguments following @a n are char *, size_t pairs. - * - * @param handle The I/O handle to receive on - * @param n The total number of char *, size_t pairs following @a n. - * - * @return -1 on error, else total number of bytes received. - */ -#if !defined (ACE_LACKS_VA_FUNCTIONS) - extern ACE_Export ssize_t recv (ACE_HANDLE handle, size_t n, ...); -#endif /* ACE_LACKS_VA_FUNCTIONS */ - - extern ACE_Export ssize_t recvv (ACE_HANDLE handle, - iovec *iov, - int iovcnt, - const ACE_Time_Value *timeout = 0); - - ACE_NAMESPACE_INLINE_FUNCTION - ssize_t recvv_n (ACE_HANDLE handle, - iovec *iov, - int iovcnt, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0); - - extern ACE_Export ssize_t recv_n (ACE_HANDLE handle, - ACE_Message_Block *message_block, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0); - - extern ACE_Export ssize_t send (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout = 0); - -#if defined (ACE_HAS_TLI) - - extern ACE_Export ssize_t t_snd (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout = 0); - -#endif /* ACE_HAS_TLI */ - - extern ACE_Export ssize_t send (ACE_HANDLE handle, - const void *buf, - size_t len, - const ACE_Time_Value *timeout = 0); - - extern ACE_Export ssize_t sendmsg (ACE_HANDLE handle, - const struct msghdr *msg, - int flags, - const ACE_Time_Value *timeout = 0); - - extern ACE_Export ssize_t sendto (ACE_HANDLE handle, - const char *buf, - int len, - int flags, - const struct sockaddr *addr, - int addrlen, - const ACE_Time_Value *timeout = 0); - - ACE_NAMESPACE_INLINE_FUNCTION - ssize_t send_n (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0); - -#if defined (ACE_HAS_TLI) - - ACE_NAMESPACE_INLINE_FUNCTION - ssize_t t_snd_n (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0); - -#endif /* ACE_HAS_TLI */ - - ACE_NAMESPACE_INLINE_FUNCTION - ssize_t send_n (ACE_HANDLE handle, - const void *buf, - size_t len, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0); - - /// Varargs variant. -#if !defined (ACE_LACKS_VA_FUNCTIONS) - extern ACE_Export ssize_t send (ACE_HANDLE handle, size_t n, ...); -#endif /* ACE_LACKS_VA_FUNCTIONS */ - - extern ACE_Export ssize_t sendv (ACE_HANDLE handle, - const iovec *iov, - int iovcnt, - const ACE_Time_Value *timeout = 0); - - ACE_NAMESPACE_INLINE_FUNCTION - ssize_t sendv_n (ACE_HANDLE handle, - const iovec *iov, - int iovcnt, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0); - - /// Send all the @a message_blocks chained through their @c next and - /// @c cont pointers. This call uses the underlying OS gather-write - /// operation to reduce the domain-crossing penalty. - extern ACE_Export ssize_t send_n (ACE_HANDLE handle, - const ACE_Message_Block *message_block, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0); - - // = File system I/O functions (these don't support timeouts). - - ACE_NAMESPACE_INLINE_FUNCTION - ssize_t read_n (ACE_HANDLE handle, - void *buf, - size_t len, - size_t *bytes_transferred = 0); - - ACE_NAMESPACE_INLINE_FUNCTION - ssize_t write_n (ACE_HANDLE handle, - const void *buf, - size_t len, - size_t *bytes_transferred = 0); - - /// Write all the @a message_blocks chained through their @c next - /// and @c cont pointers. This call uses the underlying OS - /// gather-write operation to reduce the domain-crossing penalty. - extern ACE_Export ssize_t write_n (ACE_HANDLE handle, - const ACE_Message_Block *message_block, - size_t *bytes_transferred = 0); - - extern ACE_Export ssize_t readv_n (ACE_HANDLE handle, - iovec *iov, - int iovcnt, - size_t *bytes_transferred = 0); - - extern ACE_Export ssize_t writev_n (ACE_HANDLE handle, - const iovec *iov, - int iovcnt, - size_t *bytes_transferred = 0); - //@} - - /** - * Wait up to @a timeout amount of time to passively establish a - * connection. This method doesn't perform the @c accept, it just - * does the timed wait. - */ - extern ACE_Export int handle_timed_accept (ACE_HANDLE listener, - ACE_Time_Value *timeout, - bool restart); - - /** - * Wait up to @a timeout amount of time to complete an actively - * established non-blocking connection. If @a is_tli is non-0 then - * we are being called by a TLI wrapper (which behaves slightly - * differently from a socket wrapper). - */ - extern ACE_Export ACE_HANDLE handle_timed_complete ( - ACE_HANDLE listener, - const ACE_Time_Value *timeout, - int is_tli = 0); - - /** - * Reset the limit on the number of open handles. If @a new_limit - * == -1 set the limit to the maximum allowable. Otherwise, set - * the limit value to @a new_limit. If @a increase_limit_only is - * non-0 then only allow increases to the limit. - */ - extern ACE_Export int set_handle_limit (int new_limit = -1, - int increase_limit_only = 0); - - /** - * Returns the maximum number of open handles currently permitted in - * this process. This maximum may be extended using - * @c ACE::set_handle_limit. - */ - extern ACE_Export int max_handles (void); - - // = String functions - /** - * Return a dynamically allocated duplicate of @a str, substituting - * the environment variable if @c str[0] @c == @c '$'. Note that - * the pointer is allocated with @c ACE_OS::malloc and must be freed - * by @c ACE_OS::free. - */ - extern ACE_Export ACE_TCHAR *strenvdup (const ACE_TCHAR *str); - - /// Returns a pointer to the "end" of the string, i.e., the character - /// past the '\0'. - extern ACE_Export const char *strend (const char *s); - - /// This method is just like @c strdup, except that it uses - /// @c operator @c new rather than @c malloc. If @a s is NULL - /// returns NULL rather than segfaulting. - extern ACE_Export char *strnew (const char *s); - - /// Delete the memory allocated by @c strnew. - ACE_NAMESPACE_INLINE_FUNCTION void strdelete (char *s); - - /// Create a fresh new copy of @a str, up to @a n chars long. Uses - /// @c ACE_OS::malloc to allocate the new string. - extern ACE_Export char *strndup (const char *str, size_t n); - - /// Create a fresh new copy of @a str, up to @a n chars long. Uses - /// @c ACE_OS::malloc to allocate the new string. - extern ACE_Export char *strnnew (const char *str, size_t n); - - /// Determine if a specified pathname is "dot dir" (ie. "." or ".."). - ACE_NAMESPACE_INLINE_FUNCTION bool isdotdir (const char *s); - -#if defined (ACE_HAS_WCHAR) - extern ACE_Export const wchar_t *strend (const wchar_t *s); - - extern ACE_Export wchar_t *strnew (const wchar_t *s); - - ACE_NAMESPACE_INLINE_FUNCTION void strdelete (wchar_t *s); - - extern ACE_Export wchar_t *strndup (const wchar_t *str, size_t n); - - extern ACE_Export wchar_t *strnnew (const wchar_t *str, size_t n); - - ACE_NAMESPACE_INLINE_FUNCTION bool isdotdir (const wchar_t *s); - -#endif /* ACE_HAS_WCHAR */ - - /** - * On Windows, determines if a specified pathname ends with ".exe" - * (not case sensitive). If on Windows and there is no ".exe" suffix, - * a new ACE_TCHAR array is allocated and a copy of @c pathname with - * the ".exe" suffix is copied into it. In this case, the caller is - * responsible for calling delete [] on the returned pointer. - * - * @param pathname The name to check for a proper suffix. - * - * @retval @c pathname if there is a proper suffix for Windows. This is - * always the return value for non-Windows platforms. - * @retval If a suffix needs to be added, returns a pointer to new[] - * allocated memory containing the original @c pathname plus - * a ".exe" suffix. The caller is responsible for freeing the - * memory using delete []. - */ - extern ACE_Export const ACE_TCHAR *execname (const ACE_TCHAR *pathname); - - /** - * Returns the "basename" of a @a pathname separated by @a delim. - * For instance, the basename of "/tmp/foo.cpp" is "foo.cpp" when - * @a delim is @a '/'. - */ - extern ACE_Export const ACE_TCHAR *basename (const ACE_TCHAR *pathname, - ACE_TCHAR delim = - ACE_DIRECTORY_SEPARATOR_CHAR); - - /** - * Returns the "dirname" of a @a pathname. For instance, the - * dirname of "/tmp/foo.cpp" is "/tmp" when @a delim is @a '/'. If - * @a pathname has no @a delim ".\0" is returned. This method does - * not modify @a pathname and is not reentrant. - */ - extern ACE_Export const ACE_TCHAR *dirname (const ACE_TCHAR *pathname, - ACE_TCHAR delim = - ACE_DIRECTORY_SEPARATOR_CHAR); - - /** - * Translate the given timestamp to ISO-8601 format. - * - * @param time_value ACE_Time_Value to format. This is assumed to be - * an absolute time value. - * @param date_and_time Array to hold the timestamp. - * @param time_len Size of @a date_and_time in ACE_TCHARs. - * Must be greater than or equal to 27. - * @param return_pointer_to_first_digit If true, returned pointer value - * is to the first time digit, else to the space - * prior to the first time digit. See Return Values. - * - * @retval 0 if unsuccessful, with errno set. If @a time_len is less than - * 27 errno will be EINVAL. - * @retval If successful, pointer to beginning of the "time" portion of - * @a date_and_time. If @a return_pointer_to_first_digit is false - * the pointer is actually to the space before the time, else - * the pointer is to the first time digit. - */ - extern ACE_Export ACE_TCHAR *timestamp (const ACE_Time_Value& time_value, - ACE_TCHAR date_and_time[], - size_t time_len, - bool return_pointer_to_first_digit = false); - - /** - * Translate the current time to ISO-8601 timestamp format. - * - * @param date_and_time Array to hold the timestamp. - * @param time_len Size of @a date_and_time in ACE_TCHARs. - * Must be greater than or equal to 27. - * @param return_pointer_to_first_digit If true, returned pointer value - * is to the first time digit, else to the space - * prior to the first time digit. See Return Values. - * - * @retval 0 if unsuccessful, with errno set. If @a time_len is less than - * 27 errno will be EINVAL. - * @retval If successful, pointer to beginning of the "time" portion of - * @a date_and_time. If @a return_pointer_to_first_digit is false - * the pointer is actually to the space before the time, else - * the pointer is to the first time digit. - */ - extern ACE_Export ACE_TCHAR *timestamp (ACE_TCHAR date_and_time[], - size_t time_len, - bool return_pointer_to_first_digit = false); - - /** - * if @a avoid_zombies == 0 call @c ACE_OS::fork directly, else - * create an orphan process that's inherited by the init process; - * init cleans up when the orphan process terminates so we don't - * create zombies. Returns -1 on failure and either the child PID - * on success if @a avoid_zombies == 0 or 1 on success if @a - * avoid_zombies != 0 (this latter behavior is a known bug that - * needs to be fixed). - */ - extern ACE_Export pid_t fork ( - const ACE_TCHAR *program_name = ACE_TEXT (""), - int avoid_zombies = 0); - - /** - * Become a daemon process using the algorithm in Richard Stevens - * "Advanced Programming in the UNIX Environment." If - * @a close_all_handles is non-zero then all open file handles are - * closed. - */ - extern ACE_Export int daemonize ( - const ACE_TCHAR pathname[] = ACE_TEXT ("/"), - bool close_all_handles = ACE_DEFAULT_CLOSE_ALL_HANDLES, - const ACE_TCHAR program_name[] = ACE_TEXT ("")); - - // = Miscellaneous functions. - /// Rounds the request to a multiple of the page size. - extern ACE_Export size_t round_to_pagesize (size_t len); - - /// Rounds the request to a multiple of the allocation granularity. - extern ACE_Export size_t round_to_allocation_granularity (size_t len); - - // @@ UNICODE what about buffer? - /// Format buffer into printable format. This is useful for - /// debugging. - extern ACE_Export size_t format_hexdump (const char *buffer, size_t size, - ACE_TCHAR *obuf, size_t obuf_sz); - - /// Computes the hash value of {str} using the "Hash PJW" routine. - extern ACE_Export u_long hash_pjw (const char *str); - - /// Computes the hash value of {str} using the "Hash PJW" routine. - extern ACE_Export u_long hash_pjw (const char *str, size_t len); - -#if defined (ACE_HAS_WCHAR) - /// Computes the hash value of {str} using the "Hash PJW" routine. - extern ACE_Export u_long hash_pjw (const wchar_t *str); - - /// Computes the hash value of {str} using the "Hash PJW" routine. - extern ACE_Export u_long hash_pjw (const wchar_t *str, size_t len); -#endif /* ACE_HAS_WCHAR */ - - /// Computes CRC-CCITT for the string. - extern ACE_Export ACE_UINT16 crc_ccitt(const char *str); - - /// Computes CRC-CCITT for the buffer. - extern ACE_Export ACE_UINT16 crc_ccitt(const void *buf, size_t len, - ACE_UINT16 crc = 0); - - /// Computes CRC-CCITT for the @ len iovec buffers. - extern ACE_Export ACE_UINT16 crc_ccitt(const iovec *iov, int len, - ACE_UINT16 crc = 0); - - /// Computes the ISO 8802-3 standard 32 bits CRC for the string. - extern ACE_Export ACE_UINT32 crc32 (const char *str); - - /// Computes the ISO 8802-3 standard 32 bits CRC for the buffer. - extern ACE_Export ACE_UINT32 crc32 (const void *buf, size_t len, - ACE_UINT32 crc = 0); - - /// Computes the ISO 8802-3 standard 32 bits CRC for the - /// @ len iovec buffers. - extern ACE_Export ACE_UINT32 crc32 (const iovec *iov, int len, - ACE_UINT32 crc = 0); - - /// Euclid's greatest common divisor algorithm. - extern ACE_Export u_long gcd (u_long x, u_long y); - - /// Calculates the minimum enclosing frame size for the given values. - extern ACE_Export u_long minimum_frame_size (u_long period1, u_long period2); - - /** - * Function that can burn up noticeable CPU time: brute-force - * determination of whether number @a n is prime. Returns 0 if - * it is prime, or the smallest factor if it is not prime. - * @a min_factor and @a max_factor can be used to partition the work - * among threads. For just one thread, typical values are 2 and - * n/2. - */ - extern ACE_Export u_long is_prime (const u_long n, - const u_long min_factor, - const u_long max_factor); - - /// Map troublesome win32 errno values to values that standard C - /// strerr function understands. Thank you Microsoft. - extern ACE_Export int map_errno (int error); - - /// Returns a string containing the error message corresponding to a - /// WinSock error. This works around an omission in the Win32 API. - /// @internal - extern ACE_Export const ACE_TCHAR * sock_error (int error); - - /// Determins whether the given error code corresponds to to a - /// WinSock error. If so returns true, false otherwise. - /// @internal - extern ACE_Export bool is_sock_error (int error); - - /** - * Checks if process with {pid} is still alive. Returns 1 if it is - * still alive, 0 if it isn't alive, and -1 if something weird - * happened. - */ - extern ACE_Export int process_active (pid_t pid); - - /** - * Terminate the process abruptly with id @a pid. On Win32 platforms - * this uses {TerminateProcess} and on POSIX platforms is uses - * {kill} with the -9 (SIGKILL) signal, which cannot be caught or - * ignored. Note that this call is potentially dangerous to use - * since the process being terminated may not have a chance to - * cleanup before it shuts down. - */ - extern ACE_Export int terminate_process (pid_t pid); - - /** - * This method uses process id and object pointer to come up with a - * machine wide unique name. The process ID will provide uniqueness - * between processes on the same machine. The "this" pointer of the - * {object} will provide uniqueness between other "live" objects in - * the same process. The uniqueness of this name is therefore only - * valid for the life of {object}. - */ - ACE_NAMESPACE_INLINE_FUNCTION void unique_name (const void *object, - ACE_TCHAR *name, - size_t length); - - /// Computes the base 2 logarithm of {num}. - ACE_NAMESPACE_INLINE_FUNCTION u_long log2 (u_long num); - - /// Helper to avoid comparing floating point values with == - /// (uses < and > operators). - template - bool is_equal (const T& a, const T& b) - { - return !((a < b) || (a > b)); - } - - /// Helper to avoid comparing floating point values with != - /// (uses < and > operators). - template - bool is_inequal (const T& a, const T& b) - { - return !is_equal (a, b); - } - - /// Hex conversion utility. - extern ACE_Export ACE_TCHAR nibble2hex (u_int n); - - /// Convert a hex character to its byte representation. - ACE_NAMESPACE_INLINE_FUNCTION u_char hex2byte (ACE_TCHAR c); - - // = Set/get the debug level. - extern ACE_Export bool debug (void); - extern ACE_Export void debug (bool onoff); - - /// Wrapper facade for @c select that uses @c ACE_Handle_Sets. - extern ACE_Export int select (int width, - ACE_Handle_Set *readfds, - ACE_Handle_Set *writefds = 0, - ACE_Handle_Set *exceptfds = 0, - const ACE_Time_Value *timeout = 0); - - /// Wrapper facade for the most common use of @c select that uses - /// @c ACE_Handle_Sets. - extern ACE_Export int select (int width, - ACE_Handle_Set &readfds, - const ACE_Time_Value *timeout = 0); - - /// Timed wait for handle to get read ready. - /// @retval -1 for error - /// @retval 0 for timeout - /// @retval 1 the handle is ready - ACE_NAMESPACE_INLINE_FUNCTION - int handle_read_ready (ACE_HANDLE handle, - const ACE_Time_Value *timeout); - - /// Timed wait for handle to get write ready. - /// @retval -1 for error - /// @retval 0 for timeout - /// @retval 1 the handle is ready - ACE_NAMESPACE_INLINE_FUNCTION - int handle_write_ready (ACE_HANDLE handle, - const ACE_Time_Value *timeout); - - /// Timed wait for handle to get exception ready. - /// @retval -1 for error - /// @retval 0 for timeout - /// @retval 1 the handle is ready - ACE_NAMESPACE_INLINE_FUNCTION - int handle_exception_ready (ACE_HANDLE handle, - const ACE_Time_Value *timeout); - - /// Timed wait for handle to get read, write, or exception ready. - /// @retval -1 for error - /// @retval 0 for timeout - /// @retval 1 the handle is ready - extern ACE_Export int handle_ready (ACE_HANDLE handle, - const ACE_Time_Value *timeout, - bool read_ready, - bool write_ready, - bool exception_ready); - - /// Wait for @a timeout before proceeding to a @c recv operation. - /// @a val keeps track of whether we're in non-blocking mode or - /// not. - extern ACE_Export int enter_recv_timedwait (ACE_HANDLE handle, - const ACE_Time_Value *timeout, - int &val); - - /// Wait for @a timeout before proceeding to a @c send operation. - /// @a val keeps track of whether we're in non-blocking mode or - /// not. - extern ACE_Export int enter_send_timedwait (ACE_HANDLE handle, - const ACE_Time_Value* timeout, - int &val); - - /// This makes sure that @a handle is set into non-blocking mode. - /// @a val keeps track of whether were in non-blocking mode or not. - extern ACE_Export void record_and_set_non_blocking_mode (ACE_HANDLE handle, - int &val); - - /// Cleanup after a timed operation, restore the appropriate - /// non-blocking status of @a handle. - extern ACE_Export void restore_non_blocking_mode (ACE_HANDLE handle, - int val); - - // private: - // These functions aren't meant to be used internally, so they are - // not exported. - - // - // = Recv_n helpers - // - - ACE_NAMESPACE_INLINE_FUNCTION ssize_t recv_i (ACE_HANDLE handle, - void *buf, - size_t len); - - extern ACE_Export ssize_t recv_n_i (ACE_HANDLE handle, - void *buf, - size_t len, - int flags, - size_t *bytes_transferred); - - extern ACE_Export ssize_t recv_n_i (ACE_HANDLE handle, - void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout, - size_t *bytes_transferred); - -#if defined (ACE_HAS_TLI) - - extern ACE_Export ssize_t t_rcv_n_i (ACE_HANDLE handle, - void *buf, - size_t len, - int *flags, - size_t *bytes_transferred); - - extern ACE_Export ssize_t t_rcv_n_i (ACE_HANDLE handle, - void *buf, - size_t len, - int *flags, - const ACE_Time_Value *timeout, - size_t *bytes_transferred); - -#endif /* ACE_HAS_TLI */ - - extern ACE_Export ssize_t recv_n_i (ACE_HANDLE handle, - void *buf, - size_t len, - size_t *bytes_transferred); - - extern ACE_Export ssize_t recv_n_i (ACE_HANDLE handle, - void *buf, - size_t len, - const ACE_Time_Value *timeout, - size_t *bytes_transferred); - - extern ACE_Export ssize_t recvv_n_i (ACE_HANDLE handle, - iovec *iov, - int iovcnt, - size_t *bytes_transferred); - - extern ACE_Export ssize_t recvv_n_i (ACE_HANDLE handle, - iovec *iov, - int iovcnt, - const ACE_Time_Value *timeout, - size_t *bytes_transferred); - - // - // = Send_n helpers - // - - ACE_NAMESPACE_INLINE_FUNCTION ssize_t send_i (ACE_HANDLE handle, - const void *buf, - size_t len); - - extern ACE_Export ssize_t send_n_i (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - size_t *bytes_transferred); - - extern ACE_Export ssize_t send_n_i (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout, - size_t *bytes_transferred); - -#if defined (ACE_HAS_TLI) - - extern ACE_Export ssize_t t_snd_n_i (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - size_t *bytes_transferred); - - extern ACE_Export ssize_t t_snd_n_i (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout, - size_t *bytes_transferred); - -#endif /* ACE_HAS_TLI */ - - extern ACE_Export ssize_t send_n_i (ACE_HANDLE handle, - const void *buf, - size_t len, - size_t *bytes_transferred); - - extern ACE_Export ssize_t send_n_i (ACE_HANDLE handle, - const void *buf, - size_t len, - const ACE_Time_Value *timeout, - size_t *bytes_transferred); - - extern ACE_Export ssize_t sendv_n_i (ACE_HANDLE handle, - const iovec *iov, - int iovcnt, - size_t *bytes_transferred); - - extern ACE_Export ssize_t sendv_n_i (ACE_HANDLE handle, - const iovec *iov, - int iovcnt, - const ACE_Time_Value *timeout, - size_t *bytes_transferred); -} - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/ACE.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* ACE_ACE_H */ diff --git a/deps/acelite/ace/ACE.inl b/deps/acelite/ace/ACE.inl deleted file mode 100644 index 4e7a77e5d..000000000 --- a/deps/acelite/ace/ACE.inl +++ /dev/null @@ -1,333 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_unistd.h" -#include "ace/OS_NS_Thread.h" -#include "ace/OS_NS_ctype.h" -#include "ace/OS_NS_sys_socket.h" - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Wrappers for methods that have been moved to ACE_OS. - -ACE_INLINE ssize_t -ACE::read_n (ACE_HANDLE handle, - void *buf, - size_t len, - size_t *bytes_transferred) -{ - return ACE_OS::read_n (handle, - buf, - len, - bytes_transferred); -} - -ACE_INLINE ssize_t -ACE::write_n (ACE_HANDLE handle, - const void *buf, - size_t len, - size_t *bytes_transferred) -{ - return ACE_OS::write_n (handle, - buf, - len, - bytes_transferred); -} - -ACE_INLINE ssize_t -ACE::recv_n (ACE_HANDLE handle, - void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout, - size_t *bytes_transferred) -{ - if (timeout == 0) - return ACE::recv_n_i (handle, - buf, - len, - flags, - bytes_transferred); - else - return ACE::recv_n_i (handle, - buf, - len, - flags, - timeout, - bytes_transferred); -} - -#if defined (ACE_HAS_TLI) - -ACE_INLINE ssize_t -ACE::t_rcv_n (ACE_HANDLE handle, - void *buf, - size_t len, - int *flags, - const ACE_Time_Value *timeout, - size_t *bytes_transferred) -{ - if (timeout == 0) - return ACE::t_rcv_n_i (handle, - buf, - len, - flags, - bytes_transferred); - else - return ACE::t_rcv_n_i (handle, - buf, - len, - flags, - timeout, - bytes_transferred); -} - -#endif /* ACE_HAS_TLI */ - -ACE_INLINE ssize_t -ACE::recv_n (ACE_HANDLE handle, - void *buf, - size_t len, - const ACE_Time_Value *timeout, - size_t *bytes_transferred) -{ - if (timeout == 0) - return ACE::recv_n_i (handle, - buf, - len, - bytes_transferred); - else - return ACE::recv_n_i (handle, - buf, - len, - timeout, - bytes_transferred); -} - -ACE_INLINE ssize_t -ACE::recvv_n (ACE_HANDLE handle, - iovec *iov, - int iovcnt, - const ACE_Time_Value *timeout, - size_t *bytes_transferred) -{ - if (timeout == 0) - return ACE::recvv_n_i (handle, - iov, - iovcnt, - bytes_transferred); - else - return ACE::recvv_n_i (handle, - iov, - iovcnt, - timeout, - bytes_transferred); -} - -ACE_INLINE ssize_t -ACE::send_n (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout, - size_t *bytes_transferred) -{ - if (timeout == 0) - return ACE::send_n_i (handle, - buf, - len, - flags, - bytes_transferred); - else - return ACE::send_n_i (handle, - buf, - len, - flags, - timeout, - bytes_transferred); -} - -#if defined (ACE_HAS_TLI) - -ACE_INLINE ssize_t -ACE::t_snd_n (ACE_HANDLE handle, - const void *buf, - size_t len, - int flags, - const ACE_Time_Value *timeout, - size_t *bytes_transferred) -{ - if (timeout == 0) - return ACE::t_snd_n_i (handle, - buf, - len, - flags, - bytes_transferred); - else - return ACE::t_snd_n_i (handle, - buf, - len, - flags, - timeout, - bytes_transferred); -} - -#endif /* ACE_HAS_TLI */ - -ACE_INLINE ssize_t -ACE::send_n (ACE_HANDLE handle, - const void *buf, - size_t len, - const ACE_Time_Value *timeout, - size_t *bytes_transferred) -{ - if (timeout == 0) - return ACE::send_n_i (handle, - buf, - len, - bytes_transferred); - else - return ACE::send_n_i (handle, - buf, - len, - timeout, - bytes_transferred); -} - -ACE_INLINE ssize_t -ACE::sendv_n (ACE_HANDLE handle, - const iovec *iov, - int iovcnt, - const ACE_Time_Value *timeout, - size_t *bytes_transferred) -{ - if (timeout == 0) - return ACE::sendv_n_i (handle, - iov, - iovcnt, - bytes_transferred); - else - return ACE::sendv_n_i (handle, - iov, - iovcnt, - timeout, - bytes_transferred); -} - -ACE_INLINE ssize_t -ACE::send_i (ACE_HANDLE handle, const void *buf, size_t len) -{ -#if defined (ACE_WIN32) || defined (HPUX) || defined (ACE_MQX) - return ACE_OS::send (handle, (const char *) buf, len); -#else - return ACE_OS::write (handle, (const char *) buf, len); -#endif /* ACE_WIN32 */ -} - -ACE_INLINE ssize_t -ACE::recv_i (ACE_HANDLE handle, void *buf, size_t len) -{ -#if defined (ACE_WIN32) || defined (ACE_OPENVMS) || defined (ACE_MQX) - return ACE_OS::recv (handle, (char *) buf, len); -#else - return ACE_OS::read (handle, (char *) buf, len); -#endif /* ACE_WIN32 */ -} - -ACE_INLINE int -ACE::handle_read_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout) -{ - return ACE::handle_ready (handle, timeout, true, false, false); -} - -ACE_INLINE int -ACE::handle_write_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout) -{ - return ACE::handle_ready (handle, timeout, false, true, false); -} - -ACE_INLINE int -ACE::handle_exception_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout) -{ - return ACE::handle_ready (handle, timeout, false, false, true); -} - -ACE_INLINE void -ACE::strdelete (char *s) -{ -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(s); -#else - delete [] s; -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -#if defined (ACE_HAS_WCHAR) -ACE_INLINE void -ACE::strdelete (wchar_t *s) -{ - delete [] s; -} -#endif /* ACE_HAS_WCHAR */ - -ACE_INLINE bool -ACE::isdotdir (const char *s) -{ - return (s[0] == '.' && - ((s[1] == 0) || (s[1] == '.' && s[2] == 0))); -} - -#if defined (ACE_HAS_WCHAR) -ACE_INLINE bool -ACE::isdotdir (const wchar_t *s) -{ - return (s[0] == ACE_TEXT ('.') && - ((s[1] == 0) || (s[1] == ACE_TEXT ('.') && s[2] == 0))); -} -#endif /* ACE_HAS_WCHAR */ - -ACE_INLINE void -ACE::unique_name (const void *object, - ACE_TCHAR *name, - size_t length) -{ - ACE_OS::unique_name (object, name, length); -} - -ACE_INLINE u_long -ACE::log2 (u_long num) -{ - u_long log = 0; - - for (; num > 1; ++log) - num >>= 1; - - return log; -} - -ACE_INLINE int -ACE::map_errno (int error) -{ -#if defined (ACE_WIN32) - switch (error) - { - case WSAEWOULDBLOCK: - return EAGAIN; // Same as UNIX errno EWOULDBLOCK. - } -#endif /* ACE_WIN32 */ - - return error; -} - -ACE_INLINE u_char -ACE::hex2byte (ACE_TCHAR c) -{ - if (ACE_OS::ace_isdigit (c)) - return (u_char) (c - ACE_TEXT ('0')); - else if (ACE_OS::ace_islower (c)) - return (u_char) (10 + c - ACE_TEXT ('a')); - else - return (u_char) (10 + c - ACE_TEXT ('A')); -} - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/ACE.pc.in b/deps/acelite/ace/ACE.pc.in deleted file mode 100644 index 90b2a9eeb..000000000 --- a/deps/acelite/ace/ACE.pc.in +++ /dev/null @@ -1,10 +0,0 @@ -prefix=@prefix@ -exec_prefix=@exec_prefix@ -libdir=@libdir@ -includedir=@includedir@ - -Name: ACE -Description: ADAPTIVE Communication Environment -Version: @VERSION@ -Libs: -L${libdir} -lACE @LIBS@ -Cflags: -I${includedir} diff --git a/deps/acelite/ace/ACE_crc32.cpp b/deps/acelite/ace/ACE_crc32.cpp deleted file mode 100644 index d3e994305..000000000 --- a/deps/acelite/ace/ACE_crc32.cpp +++ /dev/null @@ -1,154 +0,0 @@ -#include "ace/ACE.h" - -namespace -{ - /*****************************************************************/ - /* */ - /* CRC LOOKUP TABLE */ - /* ================ */ - /* The following CRC lookup table was generated automagically */ - /* by the Rocksoft^tm Model CRC Algorithm Table Generation */ - /* Program V1.0 using the following model parameters: */ - /* */ - /* Width : 4 bytes. */ - /* Poly : 0x04C11DB7L */ - /* Reverse : TRUE. */ - /* */ - /* For more information on the Rocksoft^tm Model CRC Algorithm, */ - /* see the document titled "A Painless Guide to CRC Error */ - /* Detection Algorithms" by Ross Williams */ - /* (ross@guest.adelaide.edu.au.). This document is likely to be */ - /* in the FTP archive "ftp.adelaide.edu.au/pub/rocksoft". */ - /* */ - /*****************************************************************/ - - const ACE_UINT32 crc_table[] = - { - 0x00000000L, 0x77073096L, 0xEE0E612CL, 0x990951BAL, - 0x076DC419L, 0x706AF48FL, 0xE963A535L, 0x9E6495A3L, - 0x0EDB8832L, 0x79DCB8A4L, 0xE0D5E91EL, 0x97D2D988L, - 0x09B64C2BL, 0x7EB17CBDL, 0xE7B82D07L, 0x90BF1D91L, - 0x1DB71064L, 0x6AB020F2L, 0xF3B97148L, 0x84BE41DEL, - 0x1ADAD47DL, 0x6DDDE4EBL, 0xF4D4B551L, 0x83D385C7L, - 0x136C9856L, 0x646BA8C0L, 0xFD62F97AL, 0x8A65C9ECL, - 0x14015C4FL, 0x63066CD9L, 0xFA0F3D63L, 0x8D080DF5L, - 0x3B6E20C8L, 0x4C69105EL, 0xD56041E4L, 0xA2677172L, - 0x3C03E4D1L, 0x4B04D447L, 0xD20D85FDL, 0xA50AB56BL, - 0x35B5A8FAL, 0x42B2986CL, 0xDBBBC9D6L, 0xACBCF940L, - 0x32D86CE3L, 0x45DF5C75L, 0xDCD60DCFL, 0xABD13D59L, - 0x26D930ACL, 0x51DE003AL, 0xC8D75180L, 0xBFD06116L, - 0x21B4F4B5L, 0x56B3C423L, 0xCFBA9599L, 0xB8BDA50FL, - 0x2802B89EL, 0x5F058808L, 0xC60CD9B2L, 0xB10BE924L, - 0x2F6F7C87L, 0x58684C11L, 0xC1611DABL, 0xB6662D3DL, - 0x76DC4190L, 0x01DB7106L, 0x98D220BCL, 0xEFD5102AL, - 0x71B18589L, 0x06B6B51FL, 0x9FBFE4A5L, 0xE8B8D433L, - 0x7807C9A2L, 0x0F00F934L, 0x9609A88EL, 0xE10E9818L, - 0x7F6A0DBBL, 0x086D3D2DL, 0x91646C97L, 0xE6635C01L, - 0x6B6B51F4L, 0x1C6C6162L, 0x856530D8L, 0xF262004EL, - 0x6C0695EDL, 0x1B01A57BL, 0x8208F4C1L, 0xF50FC457L, - 0x65B0D9C6L, 0x12B7E950L, 0x8BBEB8EAL, 0xFCB9887CL, - 0x62DD1DDFL, 0x15DA2D49L, 0x8CD37CF3L, 0xFBD44C65L, - 0x4DB26158L, 0x3AB551CEL, 0xA3BC0074L, 0xD4BB30E2L, - 0x4ADFA541L, 0x3DD895D7L, 0xA4D1C46DL, 0xD3D6F4FBL, - 0x4369E96AL, 0x346ED9FCL, 0xAD678846L, 0xDA60B8D0L, - 0x44042D73L, 0x33031DE5L, 0xAA0A4C5FL, 0xDD0D7CC9L, - 0x5005713CL, 0x270241AAL, 0xBE0B1010L, 0xC90C2086L, - 0x5768B525L, 0x206F85B3L, 0xB966D409L, 0xCE61E49FL, - 0x5EDEF90EL, 0x29D9C998L, 0xB0D09822L, 0xC7D7A8B4L, - 0x59B33D17L, 0x2EB40D81L, 0xB7BD5C3BL, 0xC0BA6CADL, - 0xEDB88320L, 0x9ABFB3B6L, 0x03B6E20CL, 0x74B1D29AL, - 0xEAD54739L, 0x9DD277AFL, 0x04DB2615L, 0x73DC1683L, - 0xE3630B12L, 0x94643B84L, 0x0D6D6A3EL, 0x7A6A5AA8L, - 0xE40ECF0BL, 0x9309FF9DL, 0x0A00AE27L, 0x7D079EB1L, - 0xF00F9344L, 0x8708A3D2L, 0x1E01F268L, 0x6906C2FEL, - 0xF762575DL, 0x806567CBL, 0x196C3671L, 0x6E6B06E7L, - 0xFED41B76L, 0x89D32BE0L, 0x10DA7A5AL, 0x67DD4ACCL, - 0xF9B9DF6FL, 0x8EBEEFF9L, 0x17B7BE43L, 0x60B08ED5L, - 0xD6D6A3E8L, 0xA1D1937EL, 0x38D8C2C4L, 0x4FDFF252L, - 0xD1BB67F1L, 0xA6BC5767L, 0x3FB506DDL, 0x48B2364BL, - 0xD80D2BDAL, 0xAF0A1B4CL, 0x36034AF6L, 0x41047A60L, - 0xDF60EFC3L, 0xA867DF55L, 0x316E8EEFL, 0x4669BE79L, - 0xCB61B38CL, 0xBC66831AL, 0x256FD2A0L, 0x5268E236L, - 0xCC0C7795L, 0xBB0B4703L, 0x220216B9L, 0x5505262FL, - 0xC5BA3BBEL, 0xB2BD0B28L, 0x2BB45A92L, 0x5CB36A04L, - 0xC2D7FFA7L, 0xB5D0CF31L, 0x2CD99E8BL, 0x5BDEAE1DL, - 0x9B64C2B0L, 0xEC63F226L, 0x756AA39CL, 0x026D930AL, - 0x9C0906A9L, 0xEB0E363FL, 0x72076785L, 0x05005713L, - 0x95BF4A82L, 0xE2B87A14L, 0x7BB12BAEL, 0x0CB61B38L, - 0x92D28E9BL, 0xE5D5BE0DL, 0x7CDCEFB7L, 0x0BDBDF21L, - 0x86D3D2D4L, 0xF1D4E242L, 0x68DDB3F8L, 0x1FDA836EL, - 0x81BE16CDL, 0xF6B9265BL, 0x6FB077E1L, 0x18B74777L, - 0x88085AE6L, 0xFF0F6A70L, 0x66063BCAL, 0x11010B5CL, - 0x8F659EFFL, 0xF862AE69L, 0x616BFFD3L, 0x166CCF45L, - 0xA00AE278L, 0xD70DD2EEL, 0x4E048354L, 0x3903B3C2L, - 0xA7672661L, 0xD06016F7L, 0x4969474DL, 0x3E6E77DBL, - 0xAED16A4AL, 0xD9D65ADCL, 0x40DF0B66L, 0x37D83BF0L, - 0xA9BCAE53L, 0xDEBB9EC5L, 0x47B2CF7FL, 0x30B5FFE9L, - 0xBDBDF21CL, 0xCABAC28AL, 0x53B39330L, 0x24B4A3A6L, - 0xBAD03605L, 0xCDD70693L, 0x54DE5729L, 0x23D967BFL, - 0xB3667A2EL, 0xC4614AB8L, 0x5D681B02L, 0x2A6F2B94L, - 0xB40BBE37L, 0xC30C8EA1L, 0x5A05DF1BL, 0x2D02EF8DL - }; - - /*****************************************************************/ - /* End of CRC Lookup Table */ - /*****************************************************************/ -} - -#define COMPUTE(var, ch) (var) = (crc_table[(var ^ ch) & 0xFF] ^ (var >> 8)) - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_UINT32 -ACE::crc32 (const char *string) -{ - ACE_UINT32 crc = 0xFFFFFFFF; - - for (const char *p = string; - *p != 0; - ++p) - { - COMPUTE (crc, *p); - } - - return ~crc; -} - -ACE_UINT32 -ACE::crc32 (const void *buffer, size_t len, ACE_UINT32 crc) -{ - crc = ~crc; - - for (const char *p = (const char *) buffer, - *e = (const char *) buffer + len; - p != e; - ++p) - { - COMPUTE (crc, *p); - } - - return ~crc; -} - -ACE_UINT32 -ACE::crc32 (const iovec *iov, int len, ACE_UINT32 crc) -{ - crc = ~crc; - - for (int i = 0; i < len; ++i) - { - for (const char *p = (const char *) iov[i].iov_base, - *e = (const char *) iov[i].iov_base + iov[i].iov_len; - p != e; - ++p) - COMPUTE (crc, *p); - } - - return ~crc; -} - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL - -#undef COMPUTE diff --git a/deps/acelite/ace/ACE_crc_ccitt.cpp b/deps/acelite/ace/ACE_crc_ccitt.cpp deleted file mode 100644 index 374637e3d..000000000 --- a/deps/acelite/ace/ACE_crc_ccitt.cpp +++ /dev/null @@ -1,122 +0,0 @@ -#include "ace/ACE.h" - -namespace -{ - /*****************************************************************/ - /* */ - /* CRC LOOKUP TABLE */ - /* ================ */ - /* The following CRC lookup table was generated automagically */ - /* by the Rocksoft^tm Model CRC Algorithm Table Generation */ - /* Program V1.0 using the following model parameters: */ - /* */ - /* Width : 2 bytes. */ - /* Poly : 0x1021 */ - /* Reverse : TRUE. */ - /* */ - /* For more information on the Rocksoft^tm Model CRC Algorithm, */ - /* see the document titled "A Painless Guide to CRC Error */ - /* Detection Algorithms" by Ross Williams */ - /* (ross@guest.adelaide.edu.au.). This document is likely to be */ - /* in the FTP archive "ftp.adelaide.edu.au/pub/rocksoft". */ - /* */ - /*****************************************************************/ - - const ACE_UINT16 crc_table[] = - { - 0x0000, 0x1189, 0x2312, 0x329B, 0x4624, 0x57AD, 0x6536, 0x74BF, - 0x8C48, 0x9DC1, 0xAF5A, 0xBED3, 0xCA6C, 0xDBE5, 0xE97E, 0xF8F7, - 0x1081, 0x0108, 0x3393, 0x221A, 0x56A5, 0x472C, 0x75B7, 0x643E, - 0x9CC9, 0x8D40, 0xBFDB, 0xAE52, 0xDAED, 0xCB64, 0xF9FF, 0xE876, - 0x2102, 0x308B, 0x0210, 0x1399, 0x6726, 0x76AF, 0x4434, 0x55BD, - 0xAD4A, 0xBCC3, 0x8E58, 0x9FD1, 0xEB6E, 0xFAE7, 0xC87C, 0xD9F5, - 0x3183, 0x200A, 0x1291, 0x0318, 0x77A7, 0x662E, 0x54B5, 0x453C, - 0xBDCB, 0xAC42, 0x9ED9, 0x8F50, 0xFBEF, 0xEA66, 0xD8FD, 0xC974, - 0x4204, 0x538D, 0x6116, 0x709F, 0x0420, 0x15A9, 0x2732, 0x36BB, - 0xCE4C, 0xDFC5, 0xED5E, 0xFCD7, 0x8868, 0x99E1, 0xAB7A, 0xBAF3, - 0x5285, 0x430C, 0x7197, 0x601E, 0x14A1, 0x0528, 0x37B3, 0x263A, - 0xDECD, 0xCF44, 0xFDDF, 0xEC56, 0x98E9, 0x8960, 0xBBFB, 0xAA72, - 0x6306, 0x728F, 0x4014, 0x519D, 0x2522, 0x34AB, 0x0630, 0x17B9, - 0xEF4E, 0xFEC7, 0xCC5C, 0xDDD5, 0xA96A, 0xB8E3, 0x8A78, 0x9BF1, - 0x7387, 0x620E, 0x5095, 0x411C, 0x35A3, 0x242A, 0x16B1, 0x0738, - 0xFFCF, 0xEE46, 0xDCDD, 0xCD54, 0xB9EB, 0xA862, 0x9AF9, 0x8B70, - 0x8408, 0x9581, 0xA71A, 0xB693, 0xC22C, 0xD3A5, 0xE13E, 0xF0B7, - 0x0840, 0x19C9, 0x2B52, 0x3ADB, 0x4E64, 0x5FED, 0x6D76, 0x7CFF, - 0x9489, 0x8500, 0xB79B, 0xA612, 0xD2AD, 0xC324, 0xF1BF, 0xE036, - 0x18C1, 0x0948, 0x3BD3, 0x2A5A, 0x5EE5, 0x4F6C, 0x7DF7, 0x6C7E, - 0xA50A, 0xB483, 0x8618, 0x9791, 0xE32E, 0xF2A7, 0xC03C, 0xD1B5, - 0x2942, 0x38CB, 0x0A50, 0x1BD9, 0x6F66, 0x7EEF, 0x4C74, 0x5DFD, - 0xB58B, 0xA402, 0x9699, 0x8710, 0xF3AF, 0xE226, 0xD0BD, 0xC134, - 0x39C3, 0x284A, 0x1AD1, 0x0B58, 0x7FE7, 0x6E6E, 0x5CF5, 0x4D7C, - 0xC60C, 0xD785, 0xE51E, 0xF497, 0x8028, 0x91A1, 0xA33A, 0xB2B3, - 0x4A44, 0x5BCD, 0x6956, 0x78DF, 0x0C60, 0x1DE9, 0x2F72, 0x3EFB, - 0xD68D, 0xC704, 0xF59F, 0xE416, 0x90A9, 0x8120, 0xB3BB, 0xA232, - 0x5AC5, 0x4B4C, 0x79D7, 0x685E, 0x1CE1, 0x0D68, 0x3FF3, 0x2E7A, - 0xE70E, 0xF687, 0xC41C, 0xD595, 0xA12A, 0xB0A3, 0x8238, 0x93B1, - 0x6B46, 0x7ACF, 0x4854, 0x59DD, 0x2D62, 0x3CEB, 0x0E70, 0x1FF9, - 0xF78F, 0xE606, 0xD49D, 0xC514, 0xB1AB, 0xA022, 0x92B9, 0x8330, - 0x7BC7, 0x6A4E, 0x58D5, 0x495C, 0x3DE3, 0x2C6A, 0x1EF1, 0x0F78 - }; - - /*****************************************************************/ - /* End of CRC Lookup Table */ - /*****************************************************************/ -} - -#define COMPUTE(var, ch) (var) = static_cast (crc_table[(var ^ ch) & 0xFF] ^ (var >> 8)) - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_UINT16 -ACE::crc_ccitt (const char *string) -{ - ACE_UINT16 crc = 0xFFFF; - - for (const char *p = string; - *p != 0; - ++p) - { - COMPUTE (crc, *p); - } - - return static_cast (~crc); -} - -ACE_UINT16 -ACE::crc_ccitt (const void *buffer, size_t len, ACE_UINT16 crc) -{ - crc = static_cast (~crc); - - for (const char *p = (const char *) buffer, - *e = (const char *) buffer + len; - p != e; - ++p) - { - COMPUTE (crc, *p); - } - - return static_cast (~crc); -} - -ACE_UINT16 -ACE::crc_ccitt (const iovec *iov, int len, ACE_UINT16 crc) -{ - crc = static_cast (~crc); - - for (int i = 0; i < len; ++i) - { - for (const char *p = (const char *) iov[i].iov_base, - *e = (const char *) iov[i].iov_base + iov[i].iov_len; - p != e; - ++p) - COMPUTE (crc, *p); - } - - return static_cast (~crc); -} - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL - -#undef COMPUTE diff --git a/deps/acelite/ace/ACE_export.h b/deps/acelite/ace/ACE_export.h deleted file mode 100644 index 7cb9fa2bb..000000000 --- a/deps/acelite/ace/ACE_export.h +++ /dev/null @@ -1,62 +0,0 @@ -// -*- C++ -*- -// Definition for Win32 Export directives. -// This file is generated automatically by -// generate_export_file.pl -// ------------------------------ - -#ifndef ACE_EXPORT_H -#define ACE_EXPORT_H - -#include /**/ "ace/config-lite.h" - -#if defined (ACE_AS_STATIC_LIBS) - -# if !defined (ACE_HAS_DLL) -# define ACE_HAS_DLL 0 -# endif /* ! ACE_HAS_DLL */ -#else -# if !defined (ACE_HAS_DLL) -# define ACE_HAS_DLL 1 -# endif /* ! ACE_HAS_DLL */ -#endif /* ACE_AS_STATIC_LIB */ - -#if defined (ACE_HAS_DLL) -# if (ACE_HAS_DLL == 1) -# if defined (ACE_BUILD_DLL) -# define ACE_Export ACE_Proper_Export_Flag -# define ACE_SINGLETON_DECLARATION(T) ACE_EXPORT_SINGLETON_DECLARATION (T) -# define ACE_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_EXPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) -# else -# define ACE_Export ACE_Proper_Import_Flag -# define ACE_SINGLETON_DECLARATION(T) ACE_IMPORT_SINGLETON_DECLARATION (T) -# define ACE_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) ACE_IMPORT_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) -# endif /* ACE_BUILD_DLL */ -# else -# define ACE_Export -# define ACE_SINGLETON_DECLARATION(T) -# define ACE_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) -# endif /* ! ACE_HAS_DLL == 1 */ -#else -# define ACE_Export -# define ACE_SINGLETON_DECLARATION(T) -# define ACE_SINGLETON_DECLARE(SINGLETON_TYPE, CLASS, LOCK) -#endif /* ACE_HAS_DLL */ - -#define ACE_NAMESPACE_STORAGE_CLASS extern ACE_EXPORT_MACRO - -#if defined (__ACE_INLINE__) -# define ACE_NAMESPACE_INLINE_FUNCTION inline -# define ACE_INLINE_TEMPLATE_FUNCTION inline -#else -# define ACE_NAMESPACE_INLINE_FUNCTION ACE_NAMESPACE_STORAGE_CLASS -// Microsoft Visual C++ will accept 'extern'; others refuse. -# if defined (_MSC_VER) || defined (__BORLANDC__) -# define ACE_INLINE_TEMPLATE_FUNCTION ACE_Export -# else -# define ACE_INLINE_TEMPLATE_FUNCTION -# endif -#endif - -#endif /* ACE_EXPORT_H */ - -// End of auto generated file. diff --git a/deps/acelite/ace/ARGV.cpp b/deps/acelite/ace/ARGV.cpp deleted file mode 100644 index 18790043e..000000000 --- a/deps/acelite/ace/ARGV.cpp +++ /dev/null @@ -1,419 +0,0 @@ -#ifndef ACE_ARGV_CPP -#define ACE_ARGV_CPP - -#include "ace/Log_Category.h" -#include "ace/OS_NS_unistd.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_Memory.h" - -#if !defined (__ACE_INLINE__) -#include "ace/ARGV.inl" -#endif /* __ACE_INLINE__ */ - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tt (ACE_ARGV_Queue_Entry_T) -ACE_ALLOC_HOOK_DEFINE_Tt (ACE_ARGV_T) - -template -void -ACE_ARGV_Queue_Entry_T::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_ARGV_Queue_Entry_T::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("arg_ = %s"), this->arg_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("quote_arg_ = %d"), (int)this->quote_arg_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -template -void -ACE_ARGV_T::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_ARGV_T::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("argc_ = %d"), this->argc_)); - - ACE_ARGV *this_obj = const_cast (this); - - for (int i = 0; i < this->argc_; i++) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("\nargv_[%i] = %s"), - i, - this_obj->argv ()[i])); - - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nbuf = %s\n"), this->buf_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n"))); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -// Creates this->argv_ out of this->buf_. New memory is allocated for -// each element of the array. This is used by the array-to-string -// style constructor and for creating this->argv_ when in iterative -// mode. - -template -int -ACE_ARGV_T::string_to_argv (void) -{ - ACE_TRACE ("ACE_ARGV_T::string_to_argv"); - - return ACE_OS::string_to_argv (this->buf_, - this->argc_, - this->argv_, - this->substitute_env_args_); -} - -template -ACE_ARGV_T::ACE_ARGV_T (const CHAR_TYPE buf[], - bool substitute_env_args) - : substitute_env_args_ (substitute_env_args), - iterative_ (false), - argc_ (0), - argv_ (0), - buf_ (0), - length_ (0), - queue_ () -{ - ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T CHAR_TYPE[] to CHAR_TYPE *[]"); - - if (buf == 0 || buf[0] == 0) - return; - - // Make an internal copy of the string. -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR(this->buf_, - static_cast (ACE_Allocator::instance()->malloc(sizeof (CHAR_TYPE) * (ACE_OS::strlen (buf) + 1)))); -#else - ACE_NEW (this->buf_, - CHAR_TYPE[ACE_OS::strlen (buf) + 1]); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - ACE_OS::strcpy (this->buf_, buf); - - // Create this->argv_. - if (this->string_to_argv () == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("string_to_argv"))); -} - -template -ACE_ARGV_T::ACE_ARGV_T (CHAR_TYPE *argv[], - bool substitute_env_args, - bool quote_arg) - : substitute_env_args_ (substitute_env_args), - iterative_ (false), - argc_ (0), - argv_ (0), - buf_ (0), - length_ (0), - queue_ () -{ - ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T CHAR_TYPE*[] to CHAR_TYPE[]"); - - if (argv == 0 || argv[0] == 0) - return; - - this->argc_ = ACE_OS::argv_to_string (argv, - this->buf_, - substitute_env_args, - quote_arg); -} - -template -ACE_ARGV_T::ACE_ARGV_T (int argc, - CHAR_TYPE *argv[], - bool substitute_env_args, - bool quote_arg) - : substitute_env_args_ (substitute_env_args), - iterative_ (false), - argc_ (0), - argv_ (0), - buf_ (0), - length_ (0), - queue_ () -{ - ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T int,CHAR_TYPE*[] to CHAR_TYPE[]"); - - this->argc_ = ACE_OS::argv_to_string (argc, - argv, - this->buf_, - substitute_env_args, - quote_arg); -} - - -template -ACE_ARGV_T::ACE_ARGV_T (CHAR_TYPE *first_argv[], - CHAR_TYPE *second_argv[], - bool substitute_env_args, - bool quote_args) - : substitute_env_args_ (substitute_env_args), - iterative_ (false), - argc_ (0), - argv_ (0), - buf_ (0), - length_ (0), - queue_ () -{ - ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T CHAR_TYPE*[] + CHAR_TYPE *[] to CHAR_TYPE[]"); - - int first_argc = 0; - int second_argc = 0; - - CHAR_TYPE *first_buf = 0; - CHAR_TYPE *second_buf = 0; - size_t buf_len = 1; - - // convert the first argv to a string - if (first_argv != 0 && first_argv[0] != 0) - { - first_argc = ACE_OS::argv_to_string (first_argv, - first_buf, - substitute_env_args, - quote_args); - buf_len += ACE_OS::strlen (first_buf); - } - - // convert the second argv to a string - if (second_argv != 0 && second_argv[0] != 0) - { - second_argc = ACE_OS::argv_to_string (second_argv, - second_buf, - substitute_env_args, - quote_args); - buf_len += ACE_OS::strlen (second_buf); - } - - // Add the number of arguments in both the argvs. - this->argc_ = first_argc + second_argc; - - // Allocate memory to the lenght of the combined argv string. - ACE_NEW (this->buf_, - CHAR_TYPE[buf_len + 1]); - - // copy the first argv string to the buffer - ACE_OS::strcpy (this->buf_, first_buf); - - // concatenate the second argv string to the buffer - ACE_OS::strcat (this->buf_, second_buf); - - // Delete the first and second buffers -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (first_buf); - ACE_Allocator::instance()->free (second_buf); -#else - delete [] first_buf; - delete [] second_buf; -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -template -ACE_ARGV_T::ACE_ARGV_T (bool substitute_env_args) - : substitute_env_args_ (substitute_env_args), - iterative_ (true), - argc_ (0), - argv_ (0), - buf_ (0), - length_ (0), - queue_ () -{ - ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T Iterative"); - - // Nothing to do yet -- the user puts in arguments via add () -} - -template -int -ACE_ARGV_T::add (const CHAR_TYPE *next_arg, bool quote_arg) -{ - // Only allow this to work in the "iterative" verion -- the - // ACE_ARGVs created with the one argument constructor. - if (!this->iterative_) - { - errno = EINVAL; - return -1; - } - - this->length_ += ACE_OS::strlen (next_arg); - if (quote_arg && ACE_OS::strchr (next_arg, ' ') != 0) - { - this->length_ += 2; - if (ACE_OS::strchr (next_arg, '"') != 0) - for (const CHAR_TYPE * p = next_arg; *p != '\0'; ++p) - if (*p == '"') ++this->length_; - } - else - { - quote_arg = false; - } - - // Put the new argument at the end of the queue. - if (this->queue_.enqueue_tail (ACE_ARGV_Queue_Entry_T (next_arg, quote_arg)) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("Can't add more to ARGV queue")), - -1); - - ++this->argc_; - - // Wipe argv_ and buf_ away so that they will be recreated if the - // user calls argv () or buf (). - if (this->argv_ != 0) - { - for (int i = 0; this->argv_[i] != 0; i++) - ACE_OS::free ((void *) this->argv_[i]); - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (this->argv_); -#else - delete [] this->argv_; -#endif /* ACE_HAS_ALLOC_HOOKS */ - this->argv_ = 0; - } - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (this->buf_); -#else - delete [] this->buf_; -#endif /* ACE_HAS_ALLOC_HOOKS */ - this->buf_ = 0; - - return 0; -} - -template -int -ACE_ARGV_T::add (CHAR_TYPE *argv[], bool quote_args) -{ - for (int i = 0; argv[i] != 0; i++) - if (this->add (argv[i], quote_args) == -1) - return -1; - - return 0; -} - -// Free up argv_ and buf_ - -template -ACE_ARGV_T::~ACE_ARGV_T (void) -{ - ACE_TRACE ("ACE_ARGV_T::~ACE_ARGV_T"); - - if (this->argv_ != 0) - for (int i = 0; this->argv_[i] != 0; i++) -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free ((void *) this->argv_[i]); -#else - ACE_OS::free ((void *) this->argv_[i]); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (this->argv_); - ACE_Allocator::instance()->free (this->buf_); -#else - delete [] this->argv_; - delete [] this->buf_; -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -// Create buf_ out of the queue_. This is only used in the -// "iterative" mode. - -template -int -ACE_ARGV_T::create_buf_from_queue (void) -{ - ACE_TRACE ("ACE_ARGV_T::create_buf_from_queue"); - - // If the are no arguments, don't do anything - if (this->argc_ <= 0) - return -1; - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (this->buf_); -#else - delete [] this->buf_; -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (this->buf_, - static_cast (ACE_Allocator::instance()->malloc(sizeof (CHAR_TYPE) * (this->length_ + this->argc_))), - -1); -#else - ACE_NEW_RETURN (this->buf_, - CHAR_TYPE[this->length_ + this->argc_], - -1); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - // Get an iterator over the queue - ACE_Unbounded_Queue_Iterator > iter (this->queue_); - - ACE_ARGV_Queue_Entry_T *arg = 0; - CHAR_TYPE *ptr = this->buf_; - size_t len; - - while (!iter.done ()) - { - // Get next argument from the queue. - iter.next (arg); - iter.advance (); - - if (arg->quote_arg_) - { - *ptr++ = '"'; - if (ACE_OS::strchr (arg->arg_, '"') != 0) - { - CHAR_TYPE prev = 0; - for (const CHAR_TYPE * p = arg->arg_; *p != '\0'; ++p) - { - if (*p == '"' && prev != '\\') *ptr++ = '\\'; - prev = *ptr++ = *p; - } - } - else - { - len = ACE_OS::strlen (arg->arg_); - // Copy the argument into buf_ - ACE_OS::memcpy ((void *) ptr, - (const void *) (arg->arg_), - len * sizeof (CHAR_TYPE)); - // Move the pointer down. - ptr += len; - } - *ptr++ = '"'; - } - else - { - len = ACE_OS::strlen (arg->arg_); - // Copy the argument into buf_ - ACE_OS::memcpy ((void *) ptr, - (const void *) (arg->arg_), - len * sizeof (CHAR_TYPE)); - // Move the pointer down. - ptr += len; - } - - // Put in an argument separating space. - *ptr++ = ' '; - } - - // Put in the NUL terminator - ptr[-1] = '\0'; - - return 0; -} - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_ARGV_CPP */ diff --git a/deps/acelite/ace/ARGV.h b/deps/acelite/ace/ARGV.h deleted file mode 100644 index 34a1cda51..000000000 --- a/deps/acelite/ace/ARGV.h +++ /dev/null @@ -1,329 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file ARGV.h - * - * @author Doug Schmidt - * @author Everett Anderson - */ -//========================================================================== - -#ifndef ACE_ARGUMENT_VECTOR_H -#define ACE_ARGUMENT_VECTOR_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Global_Macros.h" -#include "ace/Unbounded_Queue.h" - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_ARGV_Queue_Entry_T - * - * @brief An entry in the queue which keeps user supplied arguments. - */ -template -class ACE_ARGV_Queue_Entry_T -{ -public: - /// Initialize a ACE_ARGV_Queue_Entry_T. - ACE_ARGV_Queue_Entry_T (void); - - /** - * Initialize a ACE_ARGV_Queue_Entry_T. - * - * @param arg Pointer to an argument - * - * @param quote_arg The argument @a arg need to be quoted - * while adding to the vector. - */ - ACE_ARGV_Queue_Entry_T (const CHAR_TYPE *arg, - bool quote_arg); - - /** - * Initialize a ACE_ARGV_Queue_Entry_T. - * - * @param entry Pointer to a queue entry - */ - ACE_ARGV_Queue_Entry_T (const ACE_ARGV_Queue_Entry_T &entry); - - /// We need this destructor to keep some compilers from complaining. - /// It's just a no-op, however. - ~ACE_ARGV_Queue_Entry_T (void); - - /// Dump the state of this object. - void dump (void) const; - - // Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - /// Pointer to the argument. - const CHAR_TYPE * arg_; - - /// The argument need to be quoted while adding to the vector. - bool quote_arg_; -}; - -/** - * @class ACE_ARGV_T - * - * @brief Builds a counted argument vector (ala argc/argv) from either - * a string or a set of separate tokens. This class preserves whitespace - * within tokens only if the whitespace-containing token is enclosed in - * either single (') or double (") quotes. This is consistent with the - * expected behavior if an argument vector obtained using this class is - * passed to, for example, ACE_Get_Opt. - * - * This class can substitute environment variable values for tokens that - * are environment variable references (e.g., @c $VAR). This only works - * if the token is an environment variable reference and nothing else; it - * doesn't substitute environment variable references within a token. - * For example, @c $HOME/file will not substitute the value of the HOME - * environment variable. - */ -template -class ACE_ARGV_T -{ -public: - /** - * Splits the specified string into an argument vector. Arguments in the - * string are delimited by whitespace. Whitespace-containing arguments - * must be enclosed in quotes, either single (') or double ("). - * - * @param buf A nul-terminated CHAR_TYPE array to split into arguments - * for the vector. - * - * @param substitute_env_args If non-zero, any token that is an - * environment variable reference (e.g., @c $VAR) will have - * its environment variable value in the resultant vector - * in place of the environment variable name. - */ - explicit ACE_ARGV_T (const CHAR_TYPE buf[], - bool substitute_env_args = true); - - /** - * Initializes the argument vector from a set of arguments. Any environment - * variable references are translated (if applicable) during execution of - * this method. In contrast with ACE_ARGV_T(CHAR_TYPE *[], bool, bool), this - * ctor does not require argv to be 0-terminated as the number of arguments - * is provided explicitely. - * - * @param argc The number of arguments in the argv array. - * - * @param argv An array of tokens to initialize the object with. All needed - * data is copied from @a argv during this call; the pointers - * in @a argv are not needed after this call, and the memory - * referred to by @a argv is not referenced by this object. - * - * @param substitute_env_args If non-zero, any element of @a argv that is - * an environment variable reference (e.g., @c $VAR) will have - * its environment variable value in the resultant vector - * in place of the environment variable name. - * - * @param quote_args If non-zero each argument @a argv[i] needs to - * be enclosed in double quotes ('"'). - */ - explicit ACE_ARGV_T (int argc, - CHAR_TYPE *argv[], - bool substitute_env_args = true, - bool quote_args = false); - - /** - * Initializes the argument vector from a set of arguments. Any environment - * variable references are translated (if applicable) during execution of - * this method. - * - * @param argv An array of tokens to initialize the object with. The - * array must be terminated with a 0 pointer. All needed - * data is copied from @a argv during this call; the pointers - * in @a argv are not needed after this call, and the memory - * referred to by @a argv is not referenced by this object. - * - * @param substitute_env_args If non-zero, any element of @a argv that is - * an environment variable reference (e.g., @c $VAR) will have - * its environment variable value in the resultant vector - * in place of the environment variable name. - * - * @param quote_args If non-zero each argument @a argv[i] needs to - * be enclosed in double quotes ('"'). - */ - explicit ACE_ARGV_T (CHAR_TYPE *argv[], - bool substitute_env_args = true, - bool quote_args = false); - - /** - * Initializes the argument vector from two combined argument vectors. - * - * @param first_argv An array of tokens to initialize the object with. - * The array must be terminated with a 0 pointer. - * @param second_argv An array of tokens that is concatenated with the - * the tokens in @a first_argv. The array must be - * terminated with a 0 pointer. - * @param substitute_env_args If non-zero, any element of @a first_argv - * or @a second_argv that is an environment variable - * reference (e.g., @c $VAR) will have its environment - * variable value in the resultant vector in place - * of the environment variable name. - * - * @param quote_args If non-zero each arguments @a first_argv[i] and - * @a second_argv[i] needs to be enclosed - * in double quotes ('"'). - */ - ACE_ARGV_T (CHAR_TYPE *first_argv[], - CHAR_TYPE *second_argv[], - bool substitute_env_args = true, - bool quote_args = false); - - /** - * Initialize this object so arguments can be added later using one - * of the add methods. This is referred to as the @i iterative method - * of adding arguments to this object. - */ - explicit ACE_ARGV_T (bool substitute_env_args = true); - - /// Destructor. - ~ACE_ARGV_T (void); - - /** @name Accessor methods - * - * These methods access the argument vector contained in this object. - */ - //@{ - /** - * Returns the specified element of the current argument vector. - * - * @param index Index to the desired element. - * - * @retval Pointer to the indexed string. - * @retval 0 if @a index is out of bounds. - */ - const CHAR_TYPE *operator[] (size_t index); - - /** - * Returns the current argument vector. The returned pointers are to data - * maintained internally to this class. Do not change or delete either the - * pointers or the memory to which they refer. - */ - CHAR_TYPE **argv (void); - - /// Returns the current number of arguments. - int argc (void) const; - - /** - * Returns a single string form of the current arguments. The returned - * pointer refers to memory maintained internally to this class. Do not - * change or delete it. - */ - const CHAR_TYPE *buf (void); - - //@} - - /// Dump the state of this object. - void dump (void) const; - - // Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - /** - * Add another argument. This only works in the iterative mode. - * - * @note This method copies the specified pointer, but not the data - * contained in the referenced memory. Thus, if the content of - * the memory referred to by @a next_arg are changed after this - * method returns, the results are undefined. - * - * @param next_arg Pointer to the next argument to add to the vector. - * - * @param quote_arg The argument @a next_arg need to be quoted while - * adding to the vector. - * - * @retval 0 on success; -1 on failure. Most likely @c errno values are: - * - EINVAL: This object is not in iterative mode. - * - ENOMEM: Not enough memory available to save @a next_arg. - */ - int add (const CHAR_TYPE *next_arg, bool quote_arg = false); - - /** - * Add an array of arguments. This only works in the iterative mode. - * - * @note This method copies the specified pointers, but not the data - * contained in the referenced memory. Thus, if the content of - * the memory referred to by any of the @a argv elements is - * changed after this method returns, the results are undefined. - * - * @param argv Pointers to the arguments to add to the vector. - * @a argv must be terminated by a 0 pointer. - * - * @param quote_args If non-zero each argument @a argv[i] needs to - * be enclosed in double quotes ('"'). - * - * @retval 0 on success; -1 on failure. Most likely @c errno values are: - * - EINVAL: This object is not in iterative mode. - * - ENOMEM: Not enough memory available to save @a next_arg. - */ - int add (CHAR_TYPE *argv[], bool quote_args = false); - -private: - /// Copy constructor not implemented. - ACE_UNIMPLEMENTED_FUNC (ACE_ARGV_T (const ACE_ARGV_T&)) - - /// Assignment operator not implemented. - ACE_UNIMPLEMENTED_FUNC (ACE_ARGV_T operator= (const ACE_ARGV_T&)) - - /// Creates buf_ from the queue of added args, deletes previous buf_. - int create_buf_from_queue (void); - - /// Converts buf_ into the CHAR_TYPE *argv[] format. - int string_to_argv (void); - - /// Replace args with environment variable values? - bool substitute_env_args_; - - bool iterative_; - - /// Number of arguments in the ARGV array. - int argc_; - - /// The array of string arguments. - CHAR_TYPE **argv_; - - /// Buffer containing the argv contents. - CHAR_TYPE *buf_; - - /// Total length of the arguments in the queue, not counting - /// separating spaces - size_t length_; - - /// Queue which keeps user supplied arguments. This is only - /// active in the "iterative" mode. - ACE_Unbounded_Queue > queue_; -}; - -typedef ACE_ARGV_Queue_Entry_T ACE_ARGV_Queue_Entry; -typedef ACE_ARGV_T ACE_ARGV; - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/ARGV.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/ARGV.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("ARGV.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_ARGUMENT_VECTOR_H */ diff --git a/deps/acelite/ace/ARGV.inl b/deps/acelite/ace/ARGV.inl deleted file mode 100644 index cd538e9ec..000000000 --- a/deps/acelite/ace/ARGV.inl +++ /dev/null @@ -1,102 +0,0 @@ -/* -*- C++ -*- */ -#include "ace/Global_Macros.h" - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE -ACE_ARGV_Queue_Entry_T::ACE_ARGV_Queue_Entry_T (void) - : arg_(0), - quote_arg_(false) -{ - // No-op -} - -template ACE_INLINE -ACE_ARGV_Queue_Entry_T::ACE_ARGV_Queue_Entry_T (const CHAR_TYPE *arg, - bool quote_arg) - : arg_(arg), - quote_arg_(quote_arg) -{ - // No-op -} - -template ACE_INLINE -ACE_ARGV_Queue_Entry_T::ACE_ARGV_Queue_Entry_T (const ACE_ARGV_Queue_Entry_T &entry) - : arg_(entry.arg_), - quote_arg_(entry.quote_arg_) -{ - // No-op -} - -template ACE_INLINE -ACE_ARGV_Queue_Entry_T::~ACE_ARGV_Queue_Entry_T (void) -{ - // No-op just to keep some compilers happy... -} - -// Return the number of args -template -ACE_INLINE int -ACE_ARGV_T::argc (void) const -{ - ACE_TRACE ("ACE_ARGV_T::argc"); - // Try to create the argv_ if it isn't there - ACE_ARGV_T *nonconst_this = - const_cast *> (this); - (void) nonconst_this->argv (); - return this->argc_; -} - -// Return the arguments in a space-separated string -template -ACE_INLINE const CHAR_TYPE * -ACE_ARGV_T::buf (void) -{ - ACE_TRACE ("ACE_ARGV_T::buf"); - - if (this->buf_ == 0 && this->iterative_) - this->create_buf_from_queue (); - - return (const CHAR_TYPE *) this->buf_; -} - -// Return the arguments in an entry-per-argument array - -template -ACE_INLINE CHAR_TYPE ** -ACE_ARGV_T::argv (void) -{ - ACE_TRACE ("ACE_ARGV_T::argv"); - - // Try to create the argv_ if it isn't there - if (this->argv_ == 0) - { - if (this->iterative_ && this->buf_ == 0) - this->create_buf_from_queue (); - - // Convert buf_ to argv_ - if (this->string_to_argv () == -1) - return (CHAR_TYPE **) 0; - } - - return (CHAR_TYPE **) this->argv_; -} - -// Subscript operator. - -template -ACE_INLINE const CHAR_TYPE * -ACE_ARGV_T::operator[] (size_t i) -{ - ACE_TRACE ("ACE_ARGV_T::operator[]"); - - // Don't go out of bounds. - if (i >= static_cast (this->argc_)) - return 0; - - return (const CHAR_TYPE *) this->argv ()[i]; -} - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/ATM_Acceptor.cpp b/deps/acelite/ace/ATM_Acceptor.cpp deleted file mode 100644 index 1b9a03a19..000000000 --- a/deps/acelite/ace/ATM_Acceptor.cpp +++ /dev/null @@ -1,304 +0,0 @@ -#include "ace/ATM_Acceptor.h" - -#if defined (ACE_HAS_ATM) - -#if defined (ACE_HAS_LINUX_ATM) -#include /**/ "linux/atmdev.h" -#endif /* ACE_HAS_LINUX_ATM */ - -#if !defined (__ACE_INLINE__) -#include "ace/ATM_Acceptor.inl" -#endif /* __ACE_INLINE__ */ - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Put the actual definitions of the ACE_ATM_Request and -// ACE_ATM_Request_Queue classes here to hide them from clients... - -ACE_ALLOC_HOOK_DEFINE(ACE_ATM_Acceptor) - -ACE_ATM_Acceptor::ACE_ATM_Acceptor (void) -{ - ACE_TRACE ("ACE_ATM_Acceptor::ACE_ATM_Acceptor"); -} - -ACE_ATM_Acceptor::~ACE_ATM_Acceptor (void) -{ - ACE_TRACE ("ACE_ATM_Acceptor::~ACE_ATM_Acceptor"); -} - -int -ACE_ATM_Acceptor::get_local_addr (ACE_ATM_Addr &local_addr) -{ - ACE_TRACE ("ACE_ATM_Acceptor::get_local_addr"); - -#if defined (ACE_HAS_FORE_ATM_WS2) - unsigned long ret = 0; - DWORD deviceID = 0; - ATM_ADDRESS addr; - struct sockaddr_atm *laddr; - - if (::WSAIoctl ((int) ((ACE_SOCK_Acceptor *)this) -> get_handle (), - SIO_GET_ATM_ADDRESS, - (LPVOID) &deviceID, - sizeof (DWORD), - (LPVOID)&addr, - sizeof (ATM_ADDRESS), - &ret, - 0, - 0) == SOCKET_ERROR) { - ACE_OS::printf ("ATM_Acceptor (get_local_addr): WSIoctl: %d\n", - ::WSAGetLastError ()); - return -1; - } - - laddr = (struct sockaddr_atm *)local_addr.get_addr (); - ACE_OS::memcpy ((void *)& (laddr -> satm_number), - (void *)&addr, - ATM_ADDR_SIZE - 1); - - return 0; -#elif defined (ACE_HAS_FORE_ATM_XTI) - ACE_UNUSED_ARG (local_addr); - - return 0; -#elif defined (ACE_HAS_LINUX_ATM) - ATM_Addr *myaddr = (ATM_Addr *)local_addr.get_addr (); - int addrlen = sizeof (myaddr->sockaddratmsvc); - - if (ACE_OS::getsockname (acceptor_.get_handle (), - (struct sockaddr *) & (myaddr->sockaddratmsvc), - &addrlen) < 0) { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ATM_Acceptor (get_local_addr): ioctl: %d\n"), - errno)); - return -1; - } - - return 0; -#else - ACE_UNUSED_ARG (local_addr); - - return 0; -#endif /* ACE_HAS_FORE_ATM_WS2 && ACE_HAS_FORE_ATM_XTI */ -} - -ACE_HANDLE -ACE_ATM_Acceptor::open (const ACE_Addr &remote_sap, - int backlog, - ACE_ATM_Params params) -{ - ACE_TRACE ("ACE_ATM_Acceptor::open"); -#if defined (ACE_HAS_FORE_ATM_XTI) - ACE_HANDLE handle = acceptor_.open (remote_sap, - params.get_reuse_addr (), - params.get_oflag (), - params.get_info (), - backlog, - params.get_device ()); - return (handle == ACE_INVALID_HANDLE ? -1 : 0); -#elif defined (ACE_HAS_FORE_ATM_WS2) - struct sockaddr_atm local_atm_addr; - ACE_HANDLE ret; - DWORD flags = 0; - - /* Create a local endpoint of communication */ - - // Only leaves can listen. - flags = ACE_FLAG_MULTIPOINT_C_LEAF | ACE_FLAG_MULTIPOINT_D_LEAF; - - if ((ret = ACE_OS::socket (AF_ATM, - SOCK_RAW, - ATMPROTO_AAL5, - 0, - 0, - flags)) - == ACE_INVALID_HANDLE) { - ACE_OS::printf ("Acceptor (open): socket %d\n", - ::WSAGetLastError ()); - return (ret); - } - - ((ACE_SOCK_Acceptor *)this) -> set_handle (ret); - - /* Set up the address information to become a server */ - ACE_OS::memset ((void *) &local_atm_addr, 0, sizeof local_atm_addr); - local_atm_addr.satm_family = AF_ATM; - local_atm_addr.satm_number.AddressType = SAP_FIELD_ANY_AESA_REST; - local_atm_addr.satm_number.Addr[ ATM_ADDR_SIZE - 1 ] - = ((ACE_ATM_Addr *)&remote_sap) -> get_selector (); - local_atm_addr.satm_blli.Layer2Protocol = SAP_FIELD_ANY; - local_atm_addr.satm_blli.Layer3Protocol = SAP_FIELD_ABSENT; - local_atm_addr.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT; - - /* Associate address with endpoint */ - if (ACE_OS::bind (((ACE_SOCK_Acceptor *)this) -> get_handle (), - reinterpret_cast (&local_atm_addr), - sizeof local_atm_addr) == -1) { - ACE_OS::printf ("Acceptor (open): bind %d\n", ::WSAGetLastError ()); - return (ACE_INVALID_HANDLE); - } - - /* Make endpoint listen for service requests */ - if (ACE_OS::listen (( (ACE_SOCK_Acceptor *)this) -> get_handle (), - backlog) - == -1) { - ACE_OS::printf ("Acceptor (open): listen %d\n", ::WSAGetLastError ()); - return (ACE_INVALID_HANDLE); - } - - return 0; -#elif defined (ACE_HAS_LINUX_ATM) - //we need to set the qos before binding to the socket - //use remote_sap as local_sap - - ACE_ATM_Addr local_sap; - ATM_Addr *local_sap_addr = (ATM_Addr*)local_sap.get_addr (); - ACE_ATM_QoS def_qos; - ATM_QoS qos = def_qos.get_qos (); - - ACE_HANDLE handle; - if ((handle = ACE_OS::socket (params.get_protocol_family (), - params.get_type (), - params.get_protocol (), - params.get_protocol_info (), - params.get_sock_group (), - params.get_flags () - )) - == ACE_INVALID_HANDLE) { - ACELIB_DEBUG (LM_DEBUG, - ACE_TEXT ("Acceptor (socket): socket %d\n"), - errno); - return (ACE_INVALID_HANDLE); - } - - ((ACE_SOCK_Acceptor *)this) -> set_handle (handle); - if (ACE_OS::setsockopt (handle, - SOL_ATM, - SO_ATMQOS, - reinterpret_cast (&qos), - sizeof (qos)) < 0) { - ACE_OS::printf ("Acceptor (setsockopt): setsockopt:%d\n", - errno); - } - - struct atmif_sioc req; - struct sockaddr_atmsvc aux_addr[1024]; - - req.number = 0; - req.arg = aux_addr; - req.length = sizeof (aux_addr); - if (ACE_OS::ioctl (handle, - ATM_GETADDR, - &req) < 0) { - ACE_OS::perror ("Acceptor (setsockopt): ioctl:"); - } - else { - local_sap_addr->sockaddratmsvc = aux_addr[0]; - } - local_sap.set_selector (( (ACE_ATM_Addr*)&remote_sap)->get_selector ()); - - if (ACE_OS::bind (handle, - reinterpret_cast ( - &(local_sap_addr->sockaddratmsvc)), - sizeof (local_sap_addr->sockaddratmsvc) - ) == -1) { - ACELIB_DEBUG (LM_DEBUG, - ACE_TEXT ("Acceptor (open): bind %d\n"), - errno); - return -1; - } - // Make endpoint listen for service requests - if (ACE_OS::listen (handle, - backlog) - == -1) { - ACELIB_DEBUG (LM_DEBUG, - ACE_TEXT ("Acceptor (listen): listen %d\n"), - errno); - return -1; - } - - return 0; -#else - ACE_UNUSED_ARG (remote_sap); - ACE_UNUSED_ARG (backlog); - ACE_UNUSED_ARG (params); -#endif /* ACE_HAS_FORE_ATM_XTI/ACE_HAS_FORE_ATM_WS2/ACE_HAS_LINUX_ATM */ -} - -int -ACE_ATM_Acceptor::accept (ACE_ATM_Stream &new_sap, - ACE_Addr *remote_addr, - ACE_Time_Value *timeout, - bool restart, - bool reset_new_handle, - ACE_ATM_Params params, - ACE_ATM_QoS qos) -{ - ACE_TRACE ("ACE_ATM_Acceptor::accept"); -#if defined (ACE_HAS_FORE_ATM_XTI) - ATM_QoS optbuf = qos.get_qos (); - - return (acceptor_.accept (new_sap.get_stream (), - remote_addr, - timeout, - restart, - reset_new_handle, - params.get_rw_flag (), - params.get_user_data (), - &optbuf)); -#elif defined (ACE_HAS_FORE_ATM_WS2) - ACE_HANDLE n_handle; - ACE_HANDLE s_handle = ((ACE_SOCK_Acceptor *) this) -> get_handle (); - struct sockaddr_atm *cli_addr - = (struct sockaddr_atm *)remote_addr -> get_addr (); - int caddr_len = sizeof (struct sockaddr_atm); - - do { - n_handle = ACE_OS::accept (s_handle, - reinterpret_cast (cli_addr), - &caddr_len); - } while (n_handle == ACE_INVALID_HANDLE && errno == EINTR); - - ((ACE_ATM_Addr *)remote_addr) -> set (cli_addr, - ((ACE_ATM_Addr *)remote_addr) -> get_selector ()); - ((ACE_IPC_SAP *)&new_sap) -> set_handle (n_handle); - - return 0; -#elif defined (ACE_HAS_LINUX_ATM) - ACE_UNUSED_ARG (params); - - ACE_HANDLE s_handle = ((ACE_SOCK_Acceptor *) this) -> get_handle (); - struct atm_qos accept_qos = qos.get_qos (); - - if (ACE_OS::setsockopt (s_handle, - SOL_ATM, - SO_ATMQOS, - reinterpret_cast (&accept_qos), - sizeof (accept_qos)) < 0) { - ACE_OS::printf ("Acceptor (accept): error setting Qos"); - } - - return (acceptor_.accept (new_sap.get_stream (), - remote_addr, - timeout, - restart, - reset_new_handle)); -#else - ACE_UNUSED_ARG (new_sap); - ACE_UNUSED_ARG (remote_addr); - ACE_UNUSED_ARG (timeout); - ACE_UNUSED_ARG (restart); - ACE_UNUSED_ARG (reset_new_handle); - ACE_UNUSED_ARG (params); - ACE_UNUSED_ARG (qos); - return 0; -#endif /* ACE_HAS_FORE_ATM_XTI */ -} - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL - - -#endif /* ACE_HAS_ATM */ diff --git a/deps/acelite/ace/ATM_Acceptor.h b/deps/acelite/ace/ATM_Acceptor.h deleted file mode 100644 index 0b42907fa..000000000 --- a/deps/acelite/ace/ATM_Acceptor.h +++ /dev/null @@ -1,119 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file ATM_Acceptor.h - * - * @author Joe Hoffert - */ -//============================================================================= - - -#ifndef ACE_ATM_ACCEPTOR_H -#define ACE_ATM_ACCEPTOR_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_ATM) - -#include "ace/ATM_Stream.h" -#include "ace/ATM_Params.h" -#include "ace/ATM_QoS.h" - -#if defined (ACE_HAS_LINUX_ATM) -#include /**/ "atm.h" -#endif /* ACE_HAS_LINUX_ATM */ - -#if defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM) -#include "ace/SOCK_Acceptor.h" -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -typedef ACE_SOCK_Acceptor ATM_Acceptor; -ACE_END_VERSIONED_NAMESPACE_DECL -#elif defined (ACE_HAS_FORE_ATM_XTI) -#include "ace/TLI_Acceptor.h" -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -typedef ACE_TLI_Acceptor ATM_Acceptor; -ACE_END_VERSIONED_NAMESPACE_DECL -#endif // ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward declarations. -class ACE_Time_Value; - -/** - * @class ACE_ATM_Acceptor - * - * @brief Defines the member functions for ACE_ATM_Acceptor abstraction. - * - * This class wraps up the ACE_SOCK_Acceptor and ACE_TLI_Acceptor - * to make the mechanism for the ATM protocol transparent. - */ -class ACE_Export ACE_ATM_Acceptor -{ -public: - /// Default constructor. - ACE_ATM_Acceptor (void); - - ~ACE_ATM_Acceptor (); - - /// Initiate a passive mode connection. - ACE_ATM_Acceptor (const ACE_Addr &remote_sap, - int backlog = ACE_DEFAULT_BACKLOG, - ACE_ATM_Params params = ACE_ATM_Params()); - - /// Initiate a passive mode socket. - ACE_HANDLE open (const ACE_Addr &remote_sap, - int backlog = ACE_DEFAULT_BACKLOG, - ACE_ATM_Params params = ACE_ATM_Params()); - - /// Close down the acceptor and release resources. - int close (void); - - // = Passive connection acceptance method. - - /// Accept a new data transfer connection. A @a timeout of 0 means - /// block forever, a @a timeout of {0, 0} means poll. @a restart == 1 - /// means "restart if interrupted." - int accept (ACE_ATM_Stream &new_sap, - ACE_Addr *remote_addr = 0, - ACE_Time_Value *timeout = 0, - bool restart = true, - bool reset_new_handle = false, - ACE_ATM_Params params = ACE_ATM_Params(), - ACE_ATM_QoS qos = ACE_ATM_QoS()); - - /// Get the local address currently listening on - int get_local_addr( ACE_ATM_Addr &local_addr ); - - // = Meta-type info - typedef ACE_ATM_Addr PEER_ADDR; - typedef ACE_ATM_Stream PEER_STREAM; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - ATM_Acceptor acceptor_; -}; - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL - - -#if defined (__ACE_INLINE__) -#include "ace/ATM_Acceptor.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* ACE_HAS_ATM */ -#include /**/ "ace/post.h" -#endif /* ACE_ATM_ACCEPTOR_H */ diff --git a/deps/acelite/ace/ATM_Acceptor.inl b/deps/acelite/ace/ATM_Acceptor.inl deleted file mode 100644 index 8e4aef7fa..000000000 --- a/deps/acelite/ace/ATM_Acceptor.inl +++ /dev/null @@ -1,40 +0,0 @@ -// -*- C++ -*- -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE void -ACE_ATM_Acceptor::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_ATM_Acceptor::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_INLINE -ACE_ATM_Acceptor::ACE_ATM_Acceptor (const ACE_Addr &remote_sap, - int backlog, - ACE_ATM_Params params) -{ - ACE_TRACE ("ACE_ATM_Acceptor::ACE_ATM_Acceptor"); - - //FUZZ: disable check_for_lack_ACE_OS - if (open (remote_sap, backlog, params) < 0) - //FUZZ: enable check_for_lack_ACE_OS - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_ATM_Acceptor::ACE_ATM_Acceptor"))); -} - -ACE_INLINE -int -ACE_ATM_Acceptor::close (void) -{ -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM) - return (acceptor_.close()); -#else - return 0; -#endif // ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM -} - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/ATM_Addr.cpp b/deps/acelite/ace/ATM_Addr.cpp deleted file mode 100644 index 74c32b6fc..000000000 --- a/deps/acelite/ace/ATM_Addr.cpp +++ /dev/null @@ -1,517 +0,0 @@ -// Defines the Internet domain address family address format. - -#include "ace/ATM_Addr.h" -#if defined (ACE_HAS_ATM) - -#include "ace/Log_Category.h" - -#if defined (ACE_HAS_FORE_ATM_WS2) -#include /**/ "forews2.h" -#endif /* ACE_HAS_FORE_ATM_WS2 */ - -#if !defined (__ACE_INLINE__) -#include "ace/ATM_Addr.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_ATM_Addr) - -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) -#define BHLI_MAGIC "FORE_ATM" -// This is line rate in cells/s for an OC-3 MM interface. -const long ACE_ATM_Addr::LINE_RATE = 353207; -const int ACE_ATM_Addr::OPT_FLAGS_CPID = 0x1; -const int ACE_ATM_Addr::OPT_FLAGS_PMP = 0x2; -const int ACE_ATM_Addr::DEFAULT_SELECTOR = 0x99; -#elif defined (ACE_HAS_LINUX_ATM) -//pbrandao:for Linux: -//pbrandao:for now stick with current definitions -//pbrandao:see if later need to change -const long ACE_ATM_Addr::LINE_RATE = 353207; -const int ACE_ATM_Addr::OPT_FLAGS_CPID = 0; -const int ACE_ATM_Addr::OPT_FLAGS_PMP = 0; -const int ACE_ATM_Addr::DEFAULT_SELECTOR = 0x99; -#else -const long ACE_ATM_Addr::LINE_RATE = 0L; -const int ACE_ATM_Addr::OPT_FLAGS_CPID = 0; -const int ACE_ATM_Addr::OPT_FLAGS_PMP = 0; -const int ACE_ATM_Addr::DEFAULT_SELECTOR = 0x0; -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ - -// Default constructor - -ACE_ATM_Addr::ACE_ATM_Addr (u_char selector) -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) - : ACE_Addr (AF_ATM, -#elif defined (ACE_HAS_LINUX_ATM) - : ACE_Addr (PF_ATMSVC, -#else - : ACE_Addr (AF_UNSPEC, -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ - sizeof this->atm_addr_) -{ - // ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr"); - (void) ACE_OS::memset ((void *) &this->atm_addr_, - 0, - sizeof this->atm_addr_); - this->init (selector); -} - -// Copy constructor. - -ACE_ATM_Addr::ACE_ATM_Addr (const ACE_ATM_Addr &sap, - u_char selector) -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) - : ACE_Addr (AF_ATM, -#elif defined (ACE_HAS_LINUX_ATM) - : ACE_Addr (PF_ATMSVC, -#else - : ACE_Addr (AF_UNSPEC, -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ - sizeof this->atm_addr_) -{ - ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr"); - this->set (sap, selector); -#if defined (ACE_HAS_LINUX_ATM) - this->atm_addr_.sockaddratmsvc.sas_family = PF_ATMSVC; - this->atm_addr_.atmsap.blli[0].l3_proto = ATM_L3_NONE; - this->atm_addr_.atmsap.blli[0].l2_proto = ATM_L2_NONE; - this->atm_addr_.atmsap.bhli.hl_type = ATM_HL_NONE; -#endif /* ACE_HAS_LINUX_ATM */ -} - -ACE_ATM_Addr::ACE_ATM_Addr (const ATM_Addr *sap, - u_char selector) -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) - : ACE_Addr (AF_ATM, -#elif defined (ACE_HAS_LINUX_ATM) - : ACE_Addr (PF_ATMSVC, -#else - : ACE_Addr (AF_UNSPEC, -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ - sizeof this->atm_addr_) -{ - ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr"); - this->set (sap, selector); -} - - -ACE_ATM_Addr::ACE_ATM_Addr (const ACE_TCHAR sap[], - u_char selector) -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) - : ACE_Addr (AF_ATM, -#elif defined (ACE_HAS_LINUX_ATM) - : ACE_Addr (PF_ATMSVC, -#else - : ACE_Addr (AF_UNSPEC, -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ - sizeof this->atm_addr_) -{ - ACE_TRACE ("ACE_ATM_Addr::ACE_ATM_Addr"); - this->set (sap, selector); -} - -ACE_ATM_Addr::~ACE_ATM_Addr (void) -{ -} - -// Return the address. - -void * -ACE_ATM_Addr::get_addr (void) const -{ - ACE_TRACE ("ACE_ATM_Addr::get_addr"); - return (void *) &this->atm_addr_; -} - -void -ACE_ATM_Addr::init (u_char selector) -{ -#if defined (ACE_HAS_FORE_ATM_XTI) - // Note: this approach may be FORE implementation-specific. When we - // bind with tag_addr ABSENT and tag_selector PRESENT, only the - // selector (i.e. address[19]) is used by the TP. The rest of the - // local address is filled in by the TP and can be obtained via the - // 'ret' parameter or with t_getname ()/t_getprotaddr (). - - atm_addr_.addressType = (u_int16_t) AF_ATM; - - atm_addr_.sap.t_atm_sap_addr.SVE_tag_addr = (int8_t) T_ATM_ABSENT; - atm_addr_.sap.t_atm_sap_addr.SVE_tag_selector = (int8_t) T_ATM_PRESENT; - - atm_addr_.sap.t_atm_sap_addr.address_format = (u_int8_t) T_ATM_ENDSYS_ADDR; - atm_addr_.sap.t_atm_sap_addr.address_length = ATMNSAP_ADDR_LEN; - atm_addr_.sap.t_atm_sap_addr.address[ATMNSAP_ADDR_LEN - 1] = selector; - - atm_addr_.sap.t_atm_sap_layer2.SVE_tag = (int8_t) T_ATM_ABSENT; - atm_addr_.sap.t_atm_sap_layer3.SVE_tag = (int8_t) T_ATM_ABSENT; - - atm_addr_.sap.t_atm_sap_appl.SVE_tag = (int8_t) T_ATM_PRESENT; - atm_addr_.sap.t_atm_sap_appl.ID_type = (u_int8_t) T_ATM_USER_APP_ID; - - ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_appl.ID.user_defined_ID, - BHLI_MAGIC, - sizeof atm_addr_.sap.t_atm_sap_appl.ID); -#elif defined (ACE_HAS_FORE_ATM_WS2) - ACE_OS::memset ((void *)&atm_addr_, 0, sizeof atm_addr_); - atm_addr_.satm_number.Addr[ ATM_ADDR_SIZE - 1 ] = (char)selector; - atm_addr_.satm_family = AF_ATM; - atm_addr_.satm_number.AddressType = ATM_NSAP; - atm_addr_.satm_number.NumofDigits = ATM_ADDR_SIZE; - atm_addr_.satm_blli.Layer2Protocol = SAP_FIELD_ABSENT; - atm_addr_.satm_blli.Layer3Protocol = SAP_FIELD_ABSENT; - atm_addr_.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT; - - // Need to know the correspondence. - //atm_addr_.sap.t_atm_sap_appl.SVE_tag = (int8_t) T_ATM_PRESENT; - //atm_addr_.sap.t_atm_sap_appl.ID_type = (u_int8_t) T_ATM_USER_APP_ID; - //ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_appl.ID.user_defined_ID, - // BHLI_MAGIC, - // sizeof atm_addr_.sap.t_atm_sap_appl.ID); -#elif defined (ACE_HAS_LINUX_ATM) - atm_addr_.sockaddratmsvc.sas_family = AF_ATMSVC; - atm_addr_.sockaddratmsvc.sas_addr.prv[ATM_ESA_LEN - 1] = (char)selector; - atm_addr_.atmsap.blli[0].l3_proto = ATM_L3_NONE; - atm_addr_.atmsap.blli[0].l2_proto = ATM_L2_NONE; - atm_addr_.atmsap.bhli.hl_type = ATM_HL_NONE; -#else - ACE_UNUSED_ARG (selector); -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ -} - -int -ACE_ATM_Addr::set (const ACE_ATM_Addr &sap, - u_char selector) -{ - ACE_TRACE ("ACE_ATM_Addr::set"); - - this->init (selector); - - this->ACE_Addr::base_set (sap.get_type (), - sap.get_size ()); - -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) - ACE_ASSERT (sap.get_type () == AF_ATM); -#elif defined (ACE_HAS_LINUX_ATM) - ACE_ASSERT (sap.get_type () == PF_ATMSVC); -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */ - - (void) ACE_OS::memcpy ((void *) &this->atm_addr_, - (void *) &sap.atm_addr_, - sizeof this->atm_addr_); - return 0; -} - -int -ACE_ATM_Addr::set (const ATM_Addr *sap, - u_char selector) -{ - ACE_TRACE ("ACE_ATM_Addr::set"); - - this->init (selector); - -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) - this->ACE_Addr::base_set (AF_ATM, -#elif defined (ACE_HAS_LINUX_ATM) - this->ACE_Addr::base_set (PF_ATMSVC, -#else - this->ACE_Addr::base_set (AF_UNSPEC, -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */ - sizeof (*sap)); - - (void) ACE_OS::memcpy ((void *) &this->atm_addr_, - (void *) sap, - sizeof this->atm_addr_); - return 0; -} - -int -ACE_ATM_Addr::set (const ACE_TCHAR address[], - u_char selector) -{ - ACE_TRACE ("ACE_ATM_Addr::set"); - int ret; - - this->init (selector); - -#if defined (ACE_HAS_FORE_ATM_XTI) - atm_addr_.sap.t_atm_sap_addr.SVE_tag_addr = - (int8_t) T_ATM_PRESENT; -#endif /* ACE_HAS_FORE_ATM_XTI */ - - ret = this -> string_to_addr (address); - this -> set_selector (selector); - return ret; -} - -// Transform the string into the current addressing format. - -int -ACE_ATM_Addr::string_to_addr (const ACE_TCHAR sap[]) -{ - ACE_TRACE ("ACE_ATM_Addr::string_to_addr"); - -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) - this->ACE_Addr::base_set (AF_ATM, -#elif defined (ACE_HAS_LINUX_ATM) - this->ACE_Addr::base_set (PF_ATMSVC, -#else - this->ACE_Addr::base_set (AF_UNSPEC, -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ - sizeof this->atm_addr_); -#if defined (ACE_HAS_FORE_ATM_XTI) - struct hostent *entry; - struct atmnsap_addr *nsap; - - // Yow, someone gave us a NULL ATM address! - if (sap == 0) - { - errno = EINVAL; - return -1; - } - else if ((entry = gethostbyname_atmnsap ((ACE_TCHAR *)sap)) != 0) - { - ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_addr.address, - entry->h_addr_list[0], - ATMNSAP_ADDR_LEN - 1); - } - else if ((nsap = atmnsap_addr (sap)) != 0) - { - ACE_OS::memcpy (atm_addr_.sap.t_atm_sap_addr.address, - nsap->atmnsap, - ATMNSAP_ADDR_LEN); - } - else { - errno = EINVAL; - return -1; - } -#elif defined (ACE_HAS_FORE_ATM_WS2) - DWORD dwValue; - HANDLE hLookup; - WSAQUERYSETW qsRestrictions; - CSADDR_INFO csaBuffer; - WCHAR tmpWStr[100]; - - MultiByteToWideChar (CP_ACP, MB_PRECOMPOSED, sap, -1, tmpWStr, 100); - - csaBuffer.LocalAddr.iSockaddrLength = sizeof (struct sockaddr_atm); - csaBuffer.LocalAddr.lpSockaddr = (struct sockaddr *)&atm_addr_; - csaBuffer.RemoteAddr.iSockaddrLength = sizeof (struct sockaddr_atm); - csaBuffer.RemoteAddr.lpSockaddr = (struct sockaddr *)&atm_addr_; - - qsRestrictions.dwSize = sizeof (WSAQUERYSETW); - qsRestrictions.lpszServiceInstanceName = 0; - qsRestrictions.lpServiceClassId = &FORE_NAME_CLASS; - qsRestrictions.lpVersion = 0; - qsRestrictions.lpszComment = 0; - qsRestrictions.dwNameSpace = FORE_NAME_SPACE; - qsRestrictions.lpNSProviderId = 0; - qsRestrictions.lpszContext = L""; - qsRestrictions.dwNumberOfProtocols = 0; - qsRestrictions.lpafpProtocols = 0; - qsRestrictions.lpszQueryString = tmpWStr; - qsRestrictions.dwNumberOfCsAddrs = 1; - qsRestrictions.lpcsaBuffer = &csaBuffer; - qsRestrictions.lpBlob = 0; //&blob; - - if (::WSALookupServiceBeginW (&qsRestrictions, LUP_RETURN_ALL, &hLookup) - == SOCKET_ERROR) { - ACE_OS::printf ("Error: WSALookupServiceBeginW failed! %d\n", - ::WSAGetLastError ()); - return -1; - } - - dwValue = sizeof (WSAQUERYSETW); - - if (::WSALookupServiceNextW (hLookup, 0, &dwValue, &qsRestrictions) - == SOCKET_ERROR) { - if (WSAGetLastError () != WSA_E_NO_MORE) { - ACE_OS::printf ("Error: WSALookupServiceNextW failed! %d\n", - ::WSAGetLastError ()); - return -1; - } - } - - if (WSALookupServiceEnd (hLookup) == SOCKET_ERROR) { - ACE_OS::printf ("Error : WSALookupServiceEnd failed! %d\n", - ::WSAGetLastError ()); - errno = EINVAL; - return -1; - } -#elif defined (ACE_HAS_LINUX_ATM) - if (sap == 0 || !ACE_OS::strcmp (sap,"")) { - errno = EINVAL; - return -1; - } - - if (text2atm ((ACE_TCHAR *)sap, - (struct sockaddr *)& (atm_addr_.sockaddratmsvc), - sizeof (atm_addr_.sockaddratmsvc), - T2A_SVC | T2A_NAME) < 0) { - ACELIB_DEBUG (LM_DEBUG, - "Error : text2atm failed!\n"); - errno = EINVAL; - return -1; - } -#else - ACE_UNUSED_ARG (sap); - - return 0; -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ - -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM) - return 0; -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */ -} - -// Transform the current address into string format. - -int -ACE_ATM_Addr::addr_to_string (ACE_TCHAR addr[], - size_t addrlen) const -{ - ACE_TRACE ("ACE_ATM_Addr::addr_to_string"); - -#if defined (ACE_HAS_FORE_ATM_XTI) - ACE_TCHAR buffer[MAXNAMELEN + 1]; - struct atmnsap_addr nsap; - ACE_OS::memcpy (nsap.atmnsap, - atm_addr_.sap.t_atm_sap_addr.address, - ATMNSAP_ADDR_LEN); - ACE_OS::sprintf (buffer, - ACE_TEXT ("%s"), - atmnsap_ntoa (nsap)); - - size_t total_len = ACE_OS::strlen (buffer) + sizeof ('\0'); - - if (addrlen < total_len) - return -1; - else - ACE_OS::strcpy (addr, buffer); - - return 0; -#elif defined (ACE_HAS_FORE_ATM_WS2) - ACE_TCHAR buffer[MAXNAMELEN + 1]; - int i; - - if (addrlen < ATM_ADDR_SIZE + 1) - return -1; - - for (i = 0; i < ATM_ADDR_SIZE; i++) { - buffer[ i * 3 ] = '\0'; - ACE_OS::sprintf (buffer, ACE_TEXT ("%s%02x."), - buffer, - atm_addr_.satm_number.Addr[ i ]); - } - - buffer[ ATM_ADDR_SIZE * 3 - 1 ] = '\0'; - ACE_OS::strcpy (addr, buffer); - - return 0; -#elif defined (ACE_HAS_LINUX_ATM) - ACE_TCHAR buffer[MAX_ATM_ADDR_LEN + 1]; - int total_len; - if ((total_len = atm2text (buffer, - sizeof buffer, - (struct sockaddr *)& (atm_addr_.sockaddratmsvc), - A2T_PRETTY)) < 0) { - ACELIB_DEBUG ((LM_DEBUG,"ACE_ATM_Addr (addr_to_string): atm2text failed\n")); - return -1; - } - if (addrlen < (size_t)total_len) - return -1; - else - ACE_OS::strcpy (addr, - buffer); - - return 0; -#else - ACE_UNUSED_ARG (addr); - ACE_UNUSED_ARG (addrlen); - return -1; -#endif /* ACE_HAS_FORE_ATM_XTI && ACE_HAS_FORE_ATM_WS2 */ -} - -const ACE_TCHAR * -ACE_ATM_Addr::addr_to_string (void) const -{ - ACE_TRACE ("ACE_ATM_Addr::addr_to_string"); - - static ACE_TCHAR addr[MAXHOSTNAMELEN + 1]; - if (this->addr_to_string (addr, - MAXHOSTNAMELEN + 1) < 0) - return 0; - - return addr; -} - -// Set a pointer to the address. -void -ACE_ATM_Addr::set_addr (const void *addr, int len) -{ - ACE_TRACE ("ACE_ATM_Addr::set_addr"); - -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) - this->ACE_Addr::base_set (AF_ATM, -#elif defined (ACE_HAS_LINUX_ATM) - this->ACE_Addr::base_set (PF_ATMSVC, -#else - this->ACE_Addr::base_set (AF_UNSPEC, -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_WS2 */ - len); - ACE_OS::memcpy (&this->atm_addr_, addr, len); -} - -// Compare two addresses for inequality. - -bool -ACE_ATM_Addr::operator != (const ACE_ATM_Addr &sap) const -{ - ACE_TRACE ("ACE_ATM_Addr::operator !="); - return ! ((*this) == sap); -} - -// Compare two addresses for equality. - -bool -ACE_ATM_Addr::operator == (const ACE_ATM_Addr &sap) const -{ - ACE_TRACE ("ACE_ATM_Addr::operator =="); - -#if defined (ACE_HAS_LINUX_ATM) - return (atm_equal ((const struct sockaddr *)& (this->atm_addr_.sockaddratmsvc), - (const struct sockaddr *)& (sap.atm_addr_.sockaddratmsvc), - 0, - 0) - && - sap_equal (& (this->atm_addr_.atmsap), - & (sap.atm_addr_.atmsap), - 0)); -#else - return ACE_OS::memcmp (&atm_addr_, - &sap.atm_addr_, - sizeof (ATM_Addr)) == 0; -#endif /* ACE_HAS_LINUX_ATM */ -} - -void -ACE_ATM_Addr::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_ATM_Addr::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - - ACE_TCHAR s[ACE_MAX_FULLY_QUALIFIED_NAME_LEN + 16]; - ACE_OS::sprintf (s, - ACE_TEXT ("%s"), - this->addr_to_string ()); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("%s"), s)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_ATM */ diff --git a/deps/acelite/ace/ATM_Addr.h b/deps/acelite/ace/ATM_Addr.h deleted file mode 100644 index b42143a19..000000000 --- a/deps/acelite/ace/ATM_Addr.h +++ /dev/null @@ -1,193 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file ATM_Addr.h - * - * @author Joe Hoffert - */ -//========================================================================== - -#ifndef ACE_ATM_ADDR_H -#define ACE_ATM_ADDR_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_ATM) - -#include /**/ "ace/ACE_export.h" -#include "ace/Addr.h" - -#if defined (ACE_HAS_FORE_ATM_XTI) -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -typedef ATMSAPAddress ATM_Addr; -ACE_END_VERSIONED_NAMESPACE_DECL -#elif defined (ACE_HAS_FORE_ATM_WS2) -#define FORE_NAME_SPACE NS_ALL -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -typedef struct sockaddr_atm ATM_Addr; -ACE_END_VERSIONED_NAMESPACE_DECL -#elif defined (ACE_HAS_LINUX_ATM) - -#include /**/ "atm.h" - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -//pbrandao:as Linux has this 2 structs separeted we "link it" here -typedef struct _linux_atm_addr -{ - struct sockaddr_atmsvc sockaddratmsvc; - struct atm_sap atmsap; -} ATM_Addr; -#else -typedef int ATM_Addr; -#endif /* ACE_HAS_FORE_ATM_XTI/ACE_HAS_FORE_ATM_WS2/ACE_HAS_LINUX_ATM */ - -/** - * @class ACE_ATM_Addr - * - * @brief Defines the ATM domain address family address format. - */ -class ACE_Export ACE_ATM_Addr : public ACE_Addr -{ -public: - // Constants used for ATM options - static const long LINE_RATE; - static const int OPT_FLAGS_CPID; - static const int OPT_FLAGS_PMP; - static const int DEFAULT_SELECTOR; - - /// Default constructor. - ACE_ATM_Addr (u_char selector = DEFAULT_SELECTOR); - - /// Copy constructor. - ACE_ATM_Addr (const ACE_ATM_Addr &, - u_char selector = DEFAULT_SELECTOR); - - /** - * Creates an ACE_ATM_Addr from an ATMSAPAddress structure. This - * is vendor specific (FORE systems). May need to change when other - * vendors are supported. - */ - ACE_ATM_Addr (const ATM_Addr *, - u_char selector = DEFAULT_SELECTOR); - - /** - * Initializes an ACE_ATM_Addr from the which can be - * "atm-address" (e.g., - * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") or "hostname" - * (e.g., "frisbee.cs.wustl.edu"). - */ - ACE_ATM_Addr (const ACE_TCHAR sap[], - u_char selector = DEFAULT_SELECTOR); - - /// Default dtor. - ~ACE_ATM_Addr (void); - - /// Default initialization for non-address values (e.g., - /// t_atm_sap_addr.SVE_tag_addr, t_atm_sap_addr.SVE_tag_selector) - void init (u_char selector = DEFAULT_SELECTOR); - - /// Initializes from another ACE_ATM_Addr. - int set (const ACE_ATM_Addr &, - u_char selector = DEFAULT_SELECTOR); - - /** - * Initializes an ACE_ATM_Addr from an ATMSAPAddress/sockaddr_atm - * structure. This is vendor specific (FORE systems). May need to - * change when other vendors are supported. - */ - int set (const ATM_Addr *, - u_char selector = DEFAULT_SELECTOR); - - /** - * Initializes an ACE_ATM_Addr from the which can be - * "atm-address" (e.g., - * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") or "hostname" - * (e.g., "frisbee.cs.wustl.edu"). - */ - int set (const ACE_TCHAR sap[], - u_char selector = DEFAULT_SELECTOR); - - /** - * Initializes an ACE_ATM_Addr from the which can be - * "atm-address" (e.g., - * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") or "hostname" - * (e.g., "frisbee.cs.wustl.edu"). - */ - virtual int string_to_addr (const ACE_TCHAR sap[]); - - /** - * Return the character representation of the ATM address (e.g., - * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00") storing it in - * the @a addr (which is assumed to be bytes long). This - * version is reentrant. Returns -1 if the of the @a addr - * is too small, else 0. - */ - virtual int addr_to_string (ACE_TCHAR addr[], - size_t addrlen) const; - - /** - * Return the character representation of the ATM address (e.g., - * "47.0005.80.ffe100.0000.f20f.2200.0020480694f9.00"). Returns -1 - * if the of the is too small, else 0.(This version - * is non-reentrant since it returns a pointer to a static data - * area.) - */ - const ACE_TCHAR *addr_to_string (void) const; - - /// Return a pointer to the underlying network address. - virtual void *get_addr (void) const; - - /// Set a pointer to the address. - virtual void set_addr (const void *, int); - - /// Return the selector for network address. - u_char get_selector (void) const; - - /// Set the selector for the network address. - void set_selector (u_char selector); - - /** - * Compare two addresses for equality. The addresses are considered - * equal if they contain the same ATM address. Q: Is there any - * other check for equality needed for ATM? - */ - bool operator == (const ACE_ATM_Addr &SAP) const; - - /// Compare two addresses for inequality. - bool operator != (const ACE_ATM_Addr &SAP) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -// char *construct_options (ACE_HANDLE fd, -// int qos_kb, -// int flags, -// long *optsize); -// // Construct options for ATM connections - -private: - ATM_Addr atm_addr_; -}; - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL - - -#if defined (__ACE_INLINE__) -#include "ace/ATM_Addr.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* ACE_HAS_ATM */ -#include /**/ "ace/post.h" -#endif /* ACE_ATM_ADDR_H */ diff --git a/deps/acelite/ace/ATM_Addr.inl b/deps/acelite/ace/ATM_Addr.inl deleted file mode 100644 index d1f7e2c4d..000000000 --- a/deps/acelite/ace/ATM_Addr.inl +++ /dev/null @@ -1,34 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE u_char -ACE_ATM_Addr::get_selector (void) const -{ - ACE_TRACE ("ACE_ATM_Addr::get_selector"); -#if defined (ACE_HAS_FORE_ATM_XTI) - return atm_addr_.sap.t_atm_sap_addr.address[ATMNSAP_ADDR_LEN - 1]; -#elif defined (ACE_HAS_FORE_ATM_WS2) - return atm_addr_.satm_number.Addr[ ATM_ADDR_SIZE - 1 ]; -#elif defined (ACE_HAS_LINUX_ATM) - return atm_addr_.sockaddratmsvc.sas_addr.prv[ATM_ESA_LEN - 1]; -#else - return 0; -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ -} - -ACE_INLINE void -ACE_ATM_Addr::set_selector (u_char selector) -{ - ACE_TRACE ("ACE_ATM_Addr::set_selector"); -#if defined (ACE_HAS_FORE_ATM_XTI) - atm_addr_.sap.t_atm_sap_addr.address[ATMNSAP_ADDR_LEN - 1] = selector; -#elif defined (ACE_HAS_FORE_ATM_WS2) - atm_addr_.satm_number.Addr[ ATM_ADDR_SIZE - 1 ] = selector; -#elif defined (ACE_HAS_LINUX_ATM) - atm_addr_.sockaddratmsvc.sas_addr.prv[ATM_ESA_LEN - 1] = selector; -#else - ACE_UNUSED_ARG (selector); -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/ATM_Connector.cpp b/deps/acelite/ace/ATM_Connector.cpp deleted file mode 100644 index 42dd0f7a7..000000000 --- a/deps/acelite/ace/ATM_Connector.cpp +++ /dev/null @@ -1,134 +0,0 @@ -// ATM_Connector.cpp -#include "ace/ATM_Connector.h" -#if defined (ACE_HAS_ATM) - -#include "ace/Handle_Set.h" - -#if !defined (__ACE_INLINE__) -#include "ace/ATM_Connector.inl" -#endif /* __ACE_INLINE__ */ - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_ATM_Connector) - -ACE_ATM_Connector::ACE_ATM_Connector (void) -{ - ACE_TRACE ("ACE_ATM_Connector::ACE_ATM_Connector"); -} - -// Actively connect and produce a new ACE_ATM_Stream if things go well... -// Connect the to the , waiting up to -// amount of time if necessary. - -int -ACE_ATM_Connector::connect (ACE_ATM_Stream &new_stream, - const ACE_ATM_Addr &remote_sap, - ACE_ATM_Params params, - ACE_ATM_QoS options, - ACE_Time_Value *timeout, - const ACE_ATM_Addr &local_sap, - int reuse_addr, - int flags, - int perms) -{ - ACE_TRACE ("ACE_ATM_Connector::connect"); -#if defined (ACE_HAS_FORE_ATM_XTI) - return connector_.connect(new_stream.get_stream(), - remote_sap, - timeout, - local_sap, - reuse_addr, - flags, - perms, - params.get_device(), - params.get_info(), - params.get_rw_flag(), - params.get_user_data(), - &options.get_qos()); -#elif defined (ACE_HAS_FORE_ATM_WS2) - ACELIB_DEBUG(LM_DEBUG, - ACE_TEXT ("ATM_Connector(connect): set QoS parameters\n" )); - - ACE_HANDLE s = new_stream.get_handle(); - struct sockaddr_atm *saddr = ( struct sockaddr_atm *)remote_sap.get_addr(); - ACE_QoS cqos = options.get_qos(); - - ACE_QoS_Params qos_params = ACE_QoS_Params(0, - 0, - &cqos, - 0, - 0); - - ACELIB_DEBUG(LM_DEBUG, - ACE_TEXT ("ATM_Connector(connect): connecting...\n")); - - int result = ACE_OS::connect( s, - ( struct sockaddr *)saddr, - sizeof( struct sockaddr_atm ), - qos_params ); - - if ( result != 0 ) - ACE_OS::printf( "ATM_Connector(connect): connection failed, %d\n", - ::WSAGetLastError()); - - return result; -#elif defined (ACE_HAS_LINUX_ATM) - ACE_UNUSED_ARG (params); - ACE_UNUSED_ARG (timeout); - ACE_UNUSED_ARG (reuse_addr); - ACE_UNUSED_ARG (perms); - ACE_UNUSED_ARG (flags); - - ACE_HANDLE handle = new_stream.get_handle(); - ATM_QoS qos =options.get_qos(); - ATM_Addr *local_addr=(ATM_Addr*)local_sap.get_addr(), - *remote_addr=(ATM_Addr*)remote_sap.get_addr(); - - if (ACE_OS::setsockopt(handle, - SOL_ATM, - SO_ATMSAP, - reinterpret_cast (&(local_addr->atmsap)), - sizeof(local_addr->atmsap)) < 0) { - ACE_OS::printf( "ATM_Connector(connect): unable to set atmsap %d\nContinuing...", - errno); - } - if (ACE_OS::setsockopt(handle, - SOL_ATM, - SO_ATMQOS, - reinterpret_cast (&qos), - sizeof(qos)) < 0) { - ACELIB_DEBUG((LM_DEBUG,ACE_TEXT ("ATM_Connector(connect): unable to set qos %d\n"), - errno)); - return -1; - } - - int result = ACE_OS::connect(handle, - (struct sockaddr *)&(remote_addr->sockaddratmsvc), - sizeof( remote_addr->sockaddratmsvc)); - - if ( result != 0 ) - ACELIB_DEBUG(LM_DEBUG, - ACE_TEXT ("ATM_Connector(connect): connection failed, %d\n"), - errno); - - return result; -#else - ACE_UNUSED_ARG (new_stream); - ACE_UNUSED_ARG (remote_sap); - ACE_UNUSED_ARG (params); - ACE_UNUSED_ARG (options); - ACE_UNUSED_ARG (timeout); - ACE_UNUSED_ARG (local_sap); - ACE_UNUSED_ARG (reuse_addr); - ACE_UNUSED_ARG (flags); - ACE_UNUSED_ARG (perms); - return 0; -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ -} - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_ATM */ diff --git a/deps/acelite/ace/ATM_Connector.h b/deps/acelite/ace/ATM_Connector.h deleted file mode 100644 index 1f05adfae..000000000 --- a/deps/acelite/ace/ATM_Connector.h +++ /dev/null @@ -1,161 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file ATM_Connector.h - * - * @author Joe Hoffert - */ -//============================================================================= - -#ifndef ACE_ATM_CONNECTOR_H -#define ACE_ATM_CONNECTOR_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_ATM) - -#include "ace/ATM_Stream.h" -#include "ace/ATM_Params.h" -#include "ace/ATM_QoS.h" - -#if defined (ACE_WIN32) || defined (ACE_HAS_LINUX_ATM) -#include "ace/SOCK_Connector.h" -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -typedef ACE_SOCK_Connector ATM_Connector; -ACE_END_VERSIONED_NAMESPACE_DECL -#else -#include "ace/XTI_ATM_Mcast.h" -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -typedef ACE_XTI_ATM_Mcast ATM_Connector; -// Open versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL -#endif - -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_ATM_Connector - * - * @brief Defines an active connection factory for the ACE_ATM C++ - * wrappers. - */ -class ACE_Export ACE_ATM_Connector -{ -public: - /// Default constructor. - ACE_ATM_Connector (void); - - /** - * Actively connect and produce a @a new_stream if things go well. - * The @a remote_sap is the address that we are trying to connect - * with. The are the parameters needed for either socket - * or XTI/ATM connections. The @a timeout is the amount of time to - * wait to connect. If it's 0 then we block indefinitely. If - * *timeout == {0, 0} then the connection is done using non-blocking - * mode. In this case, if the connection can't be made immediately - * the value of -1 is returned with @c errno == EWOULDBLOCK. If - * *timeout > {0, 0} then this is the maximum amount of time to wait before - * timing out. If the time expires before the connection is made - * @c errno == ETIME. The @a local_sap is the value of local address - * to bind to. If it's the default value of then - * the user is letting the OS do the binding. If @a reuse_addr == 1 - * then the is reused, even if it hasn't been cleanedup yet. - */ - ACE_ATM_Connector (ACE_ATM_Stream &new_stream, - const ACE_ATM_Addr &remote_sap, - ACE_ATM_Params params = ACE_ATM_Params(), - ACE_ATM_QoS options = ACE_ATM_QoS(), - ACE_Time_Value *timeout = 0, - const ACE_ATM_Addr &local_sap = ACE_ATM_Addr( "", 0 ), - int reuse_addr = 0, -#if defined (ACE_WIN32) - int flags = 0, -#else - int flags = O_RDWR, -#endif /* ACE_WIN32 */ - int perms = 0); - - /** - * Actively connect and produce a @a new_stream if things go well. - * The @a remote_sap is the address that we are trying to connect - * with. The are the parameters needed for either socket - * or XTI/ATM connections. The @a timeout is the amount of time to - * wait to connect. If it's 0 then we block indefinitely. If - * *timeout == {0, 0} then the connection is done using non-blocking - * mode. In this case, if the connection can't be made immediately - * the value of -1 is returned with @c errno == EWOULDBLOCK. If - * *timeout > {0, 0} then this is the maximum amount of time to wait before - * timing out. If the time expires before the connection is made - * @c errno == ETIME. The @a local_sap is the value of local address - * to bind to. If it's the default value of then - * the user is letting the OS do the binding. If @a reuse_addr == 1 - * then the is reused, even if it hasn't been cleanedup yet. - */ - int connect (ACE_ATM_Stream &new_stream, - const ACE_ATM_Addr &remote_sap, - ACE_ATM_Params params = ACE_ATM_Params(), - ACE_ATM_QoS options = ACE_ATM_QoS(), - ACE_Time_Value *timeout = 0, - const ACE_ATM_Addr &local_sap = ACE_ATM_Addr( "", - 0 ), - int reuse_addr = 0, -#if defined (ACE_WIN32) - int flags = 0, -#else - int flags = O_RDWR, -#endif /* ACE_WIN32 */ - int perms = 0); - - /** - * Try to complete a non-blocking connection. - * If connection completion is successful then @a new_stream contains - * the connected ACE_SOCK_Stream. If @a remote_sap is non-NULL then it - * will contain the address of the connected peer. - */ - int complete (ACE_ATM_Stream &new_stream, - ACE_ATM_Addr *remote_sap, - ACE_Time_Value *tv); - - /** - * Actively add a leaf to the root (i.e., point-to-multipoint). The - * @a remote_sap is the address of the leaf that we - * are trying to add. - */ - int add_leaf (ACE_ATM_Stream ¤t_stream, - const ACE_Addr &remote_sap, - ACE_ATM_QoS &qos); - - /// Resets any event associations on this handle - bool reset_new_handle (ACE_HANDLE handle); - - // = Meta-type info - typedef ACE_ATM_Addr PEER_ADDR; - typedef ACE_ATM_Stream PEER_STREAM; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - ATM_Connector connector_; -}; - -// Open versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/ATM_Connector.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* ACE_HAS_ATM */ -#include /**/ "ace/post.h" -#endif /* ACE_ATM_CONNECTOR_H */ diff --git a/deps/acelite/ace/ATM_Connector.inl b/deps/acelite/ace/ATM_Connector.inl deleted file mode 100644 index e35f40854..000000000 --- a/deps/acelite/ace/ATM_Connector.inl +++ /dev/null @@ -1,129 +0,0 @@ -// -*- C++ -*- -// Open versioned namespace, if enabled by the user. -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE void -ACE_ATM_Connector::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_ATM_Connector::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_INLINE -ACE_ATM_Connector::ACE_ATM_Connector (ACE_ATM_Stream &new_stream, - const ACE_ATM_Addr &remote_sap, - ACE_ATM_Params params, - ACE_ATM_QoS options, - ACE_Time_Value *timeout, - const ACE_ATM_Addr &local_sap, - int reuse_addr, - int flags, - int perms) -{ - ACE_TRACE ("ACE_ATM_Connector::ACE_ATM_Connector"); - if ((ACE_HANDLE)this->connect (new_stream, - remote_sap, - params, - options, - timeout, - local_sap, - reuse_addr, - flags, - perms) == ACE_INVALID_HANDLE - && timeout != 0 && !(errno == EWOULDBLOCK || errno == ETIME)) - ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_ATM_Stream::ACE_ATM_Stream"))); -} - -// Try to complete a non-blocking connection. - -ACE_INLINE -int -ACE_ATM_Connector::complete (ACE_ATM_Stream &new_stream, - ACE_ATM_Addr *remote_sap, - ACE_Time_Value *tv) -{ - ACE_TRACE ("ACE_ATM_Connector::complete"); -#if defined (ACE_HAS_ATM) - return connector_.complete(new_stream.get_stream(), - remote_sap, - tv); -#else - ACE_UNUSED_ARG(new_stream); - ACE_UNUSED_ARG(remote_sap); - ACE_UNUSED_ARG(tv); - return 0; -#endif -} - -ACE_INLINE -int -ACE_ATM_Connector::add_leaf (ACE_ATM_Stream ¤t_stream, - const ACE_Addr &remote_sap, - ACE_ATM_QoS &qos) -{ - ACE_TRACE ("ACE_ATM_Connector::add_leaf"); -#if defined (ACE_HAS_FORE_ATM_XTI) - return connector_.add_leaf(current_stream.get_stream(), - remote_sap, - leaf_id, - timeout); -#elif defined (ACE_HAS_FORE_ATM_WS2) - struct sockaddr_atm *saddr = (struct sockaddr_atm *)remote_sap.get_addr(); - ACE_QoS cqos = qos.get_qos(); - int addr_len = sizeof( struct sockaddr_atm ); - - ACE_QoS_Params qos_params(0, - 0, - &cqos, - 0, - (JL_SENDER_ONLY)); - - ACE_OS::printf( "ATM_Connector::add_leaf: connecting...\n" ); - - ACE_HANDLE result = ACE_OS::join_leaf(current_stream.get_handle(), - (struct sockaddr *)saddr, - addr_len, - qos_params); - - if ( result == ACE_INVALID_HANDLE ) - ACE_OS::printf( "ATM_Connector(add_leaf): connection failed, %d\n", - ::WSAGetLastError()); - - return (result != ACE_INVALID_HANDLE); -#elif defined (ACE_HAS_LINUX_ATM) - ACE_OS::printf("ATM_Connector(add_leaf): not yet implemented in Linux\n"); - - ACE_UNUSED_ARG(current_stream); - ACE_UNUSED_ARG(remote_sap); - ACE_UNUSED_ARG(leaf_id); - ACE_UNUSED_ARG(timeout); - - return 0; -#else - ACE_UNUSED_ARG(current_stream); - ACE_UNUSED_ARG(remote_sap); - ACE_UNUSED_ARG(leaf_id); - ACE_UNUSED_ARG(timeout); - return 0; -#endif -} - -ACE_INLINE -bool -ACE_ATM_Connector::reset_new_handle (ACE_HANDLE handle) -{ -#if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) - // Reset the event association - return ::WSAEventSelect ((SOCKET) handle, - 0, - 0); -#else /* !defined ACE_HAS_WINSOCK2 */ - ACE_UNUSED_ARG (handle); - return false; -#endif /* ACE_WIN32 */ -} - -// Close versioned namespace, if enabled by the user. -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/ATM_Params.cpp b/deps/acelite/ace/ATM_Params.cpp deleted file mode 100644 index 92d3ecef5..000000000 --- a/deps/acelite/ace/ATM_Params.cpp +++ /dev/null @@ -1,16 +0,0 @@ -#include "ace/ATM_Params.h" - -#if defined (ACE_HAS_ATM) - -#if !defined (__ACE_INLINE__) -#include "ace/ATM_Params.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_ATM_Params) - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_ATM */ - diff --git a/deps/acelite/ace/ATM_Params.h b/deps/acelite/ace/ATM_Params.h deleted file mode 100644 index 34db50248..000000000 --- a/deps/acelite/ace/ATM_Params.h +++ /dev/null @@ -1,212 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file ATM_Params.h - * - * @author Joe Hoffert - */ -//========================================================================== - - -#ifndef ACE_ATM_PARAMS_H -#define ACE_ATM_PARAMS_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_ATM) - -#include /**/ "ace/ACE_export.h" - -#if defined (ACE_HAS_FORE_ATM_XTI) -#include "ace/TLI.h" -#define ATM_PROTOCOL_DEFAULT 0 -typedef struct t_info Param_Info; -typedef struct netbuf Param_Udata; -#elif defined (ACE_HAS_FORE_ATM_WS2) -#include "ace/SOCK.h" -#define ATM_PROTOCOL_DEFAULT ATMPROTO_AAL5 -#define ACE_XTI_ATM_DEVICE "" -typedef int Param_Info; -typedef int Param_Udata; -#elif defined (ACE_HAS_LINUX_ATM) -#include /**/ "atm.h" -#define AF_ATM PF_ATMSVC -#define ACE_XTI_ATM_DEVICE "" -#define ATM_PROTOCOL_DEFAULT ATM_AAL5 -typedef int Param_Info; -typedef int Param_Udata; -#else -#define ACE_XTI_ATM_DEVICE "" -typedef int Param_Info; -typedef int Param_Udata; -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_ATM_Params - * - * @brief Wrapper class that simplifies the information passed to the ATM - * enabled ACE_ATM_Connector class. - */ -class ACE_Export ACE_ATM_Params -{ -public: - /** - * Initialize the data members. This class combines options from - * ACE_SOCK_Connector (@a protocol_family, @a protocol, , - * @a protocol_info, , and @a flags) and - * ACE_TLI_Connector (, , , , and ) - * so that either mechanism can be used transparently for ATM. - */ - ACE_ATM_Params (int rw_flag = 1, - const char device[] = ACE_XTI_ATM_DEVICE, - Param_Info *info = 0, - Param_Udata *udata = 0, - int oflag = O_RDWR, - int protocol_family = AF_ATM, - int protocol = ATM_PROTOCOL_DEFAULT, - int type = -#if defined (ACE_HAS_LINUX_ATM) - SOCK_DGRAM, -#else - SOCK_RAW, -#endif /* ACE_HAS_LINUX_ATM */ - ACE_Protocol_Info *protocol_info = 0, - ACE_SOCK_GROUP g = 0, - u_long flags - = ACE_FLAG_MULTIPOINT_C_ROOT - | ACE_FLAG_MULTIPOINT_D_ROOT, // connector by default - int reuse_addr = 0); - - /// Destructor. - ~ACE_ATM_Params (); - - /// Get protocol family. - int get_protocol_family (void) const; - - /// Set protocol family. - void set_protocol_family (int); - - /// Get protocol. - int get_protocol (void) const; - - /// Set protocol. - void set_protocol (int); - - /// Get type. - int get_type (void) const; - - /// Set type. - void set_type (int); - - /// Get protocol info. - ACE_Protocol_Info *get_protocol_info( void ); - - /// Set protocol info. - void set_protocol_info( ACE_Protocol_Info *); - - /// Get socket group. - ACE_SOCK_GROUP get_sock_group( void ); - - /// Set socket group. - void set_sock_group( ACE_SOCK_GROUP ); - - /// Get socket flags. - u_long get_flags( void ); - - /// Set socket flags. - void set_flags( u_long ); - - /// Get reuse_addr flag. - int get_reuse_addr (void) const; - - /// Set reuse_addr flag. - void set_reuse_addr (int); - - /// Get device. - const char* get_device (void) const; - - /// Get info. - Param_Info* get_info (void) const; - - /// Set info. - void set_info (Param_Info *); - - /// Get r/w flag. - int get_rw_flag (void) const; - - /// Set r/w flag. - void set_rw_flag (int); - - /// Get user data. - Param_Udata* get_user_data (void) const; - - /// Set user data. - void set_user_data (Param_Udata*); - - /// Get open flag. - int get_oflag (void) const; - - /// Set open flag. - void set_oflag (int); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Protocol family for sockets connections. - int protocol_family_; - - /// Protocol for sockets connections. - int protocol_; - - /// Type for opening sockets. - int type_; - - /// Information about the protocol. - ACE_Protocol_Info *protocol_info_; - - /// Socket group used (for sockets only). - ACE_SOCK_GROUP group_; - - /// Flags for sockets (for sockets only). - u_long flags_; - - /// Flag for reusing address for opening sockets. - int reuse_addr_; - - /// Device name for XTI/ATM connections. - const char *device_; - - /// Info for XTI/ATM connections. - Param_Info *info_; - - /// R/W flag for XTI/ATM connections. - int rw_flag_; - - /// User data for XTI/ATM connections. - Param_Udata *udata_; - - /// Open flag for XTI/ATM connections. - int oflag_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/ATM_Params.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* ACE_HAS_ATM */ -#include /**/ "ace/post.h" -#endif /* ACE_ATM_PARAMS_H */ diff --git a/deps/acelite/ace/ATM_Params.inl b/deps/acelite/ace/ATM_Params.inl deleted file mode 100644 index 59ec331b5..000000000 --- a/deps/acelite/ace/ATM_Params.inl +++ /dev/null @@ -1,232 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE void -ACE_ATM_Params::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_ATM_Params::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_INLINE -ACE_ATM_Params::ACE_ATM_Params (int rw_flag, - const char device[], - Param_Info *info, - Param_Udata *udata, - int oflag, - int protocol_family, - int protocol, - int type, - ACE_Protocol_Info *protocol_info, - ACE_SOCK_GROUP g, - u_long flags, - int reuse_addr) - : protocol_family_(protocol_family), - protocol_(protocol), - type_(type), - protocol_info_(protocol_info), - group_(g), - flags_(flags), - reuse_addr_(reuse_addr), - device_(device), - info_(info), - rw_flag_(rw_flag), - udata_(udata), - oflag_(oflag) -{ - ACE_TRACE ("ACE_ATM_Params::ACE_ATM_Params"); -} - -// Default dtor. -ACE_INLINE -ACE_ATM_Params::~ACE_ATM_Params (void) -{ - ACE_TRACE ("ACE_ATM_Params::~ACE_ATM_Params"); -} - -ACE_INLINE -int -ACE_ATM_Params::get_protocol_family (void) const -{ - ACE_TRACE ("ACE_ATM_Params::get_protocol_family"); - return protocol_family_; -} - -ACE_INLINE -void -ACE_ATM_Params::set_protocol_family (int family) -{ - ACE_TRACE ("ACE_ATM_Params::set_protocol_family"); - protocol_family_ = family; -} - -ACE_INLINE -int -ACE_ATM_Params::get_protocol (void) const -{ - ACE_TRACE ("ACE_ATM_Params::get_protocol"); - return protocol_; -} - -ACE_INLINE -void -ACE_ATM_Params::set_protocol (int protocol) -{ - ACE_TRACE ("ACE_ATM_Params::set_protocol"); - protocol_ = protocol; -} - -ACE_INLINE -int -ACE_ATM_Params::get_type (void) const -{ - ACE_TRACE ("ACE_ATM_Params::get_type"); - return type_; -} - -ACE_INLINE -void -ACE_ATM_Params::set_type (int type) -{ - ACE_TRACE ("ACE_ATM_Params::set_type"); - type_ = type; -} - -ACE_INLINE -ACE_Protocol_Info* -ACE_ATM_Params::get_protocol_info( void ) -{ - ACE_TRACE ("ACE_ATM_Params::get_protocol_info"); - return protocol_info_; -} - -ACE_INLINE -void -ACE_ATM_Params::set_protocol_info( ACE_Protocol_Info *protocol_info ) -{ - ACE_TRACE ("ACE_ATM_Params::set_protocol_info"); - protocol_info_ = protocol_info; -} - -ACE_INLINE -ACE_SOCK_GROUP -ACE_ATM_Params::get_sock_group( void ) -{ - ACE_TRACE ("ACE_ATM_Params::get_sock_group"); - return group_; -} - -ACE_INLINE -void -ACE_ATM_Params::set_sock_group( ACE_SOCK_GROUP g ) -{ - ACE_TRACE ("ACE_ATM_Params::set_sock_group"); - group_ = g; -} - -ACE_INLINE -u_long -ACE_ATM_Params::get_flags( void ) -{ - ACE_TRACE ("ACE_ATM_Params::get_flags"); - return flags_; -} - -ACE_INLINE -void -ACE_ATM_Params::set_flags( u_long flags) -{ - ACE_TRACE ("ACE_ATM_Params::set_flags"); - flags_ = flags; -} - -ACE_INLINE -int -ACE_ATM_Params::get_reuse_addr (void) const -{ - ACE_TRACE ("ACE_ATM_Params::get_reuse_addr"); - return reuse_addr_; -} - -ACE_INLINE -void -ACE_ATM_Params::set_reuse_addr (int reuse_addr) -{ - ACE_TRACE ("ACE_ATM_Params::set_reuse_addr"); - reuse_addr_ = reuse_addr; -} - -ACE_INLINE -const char* -ACE_ATM_Params::get_device (void) const -{ - ACE_TRACE ("ACE_ATM_Params::get_device"); - return device_; -} - -ACE_INLINE -Param_Info* -ACE_ATM_Params::get_info (void) const -{ - ACE_TRACE ("ACE_ATM_Params::get_info"); - return info_; -} - -ACE_INLINE -void -ACE_ATM_Params::set_info (Param_Info* info) -{ - ACE_TRACE ("ACE_ATM_Params::set_info"); - info_ = info; -} - -ACE_INLINE -int -ACE_ATM_Params::get_rw_flag (void) const -{ - ACE_TRACE ("ACE_ATM_Params::get_rw_flag"); - return rw_flag_; -} - -ACE_INLINE -void -ACE_ATM_Params::set_rw_flag (int rw_flag) -{ - ACE_TRACE ("ACE_ATM_Params::set_rw_flag"); - rw_flag_ = rw_flag; -} - -ACE_INLINE -Param_Udata* -ACE_ATM_Params::get_user_data (void) const -{ - ACE_TRACE ("ACE_ATM_Params::get_user_data"); - return udata_; -} - -ACE_INLINE -void -ACE_ATM_Params::set_user_data (Param_Udata *udata) -{ - ACE_TRACE ("ACE_ATM_Params::set_user_data"); - udata_ = udata; -} - -ACE_INLINE -int -ACE_ATM_Params::get_oflag (void) const -{ - ACE_TRACE ("ACE_ATM_Params::get_oflag"); - return oflag_; -} - -ACE_INLINE -void -ACE_ATM_Params::set_oflag (int oflag) -{ - ACE_TRACE ("ACE_ATM_Params::set_oflag"); - oflag_ = oflag; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/ATM_QoS.cpp b/deps/acelite/ace/ATM_QoS.cpp deleted file mode 100644 index b291d0e5b..000000000 --- a/deps/acelite/ace/ATM_QoS.cpp +++ /dev/null @@ -1,627 +0,0 @@ -#include "ace/ATM_QoS.h" - -#if defined (ACE_HAS_ATM) - -#if !defined (__ACE_INLINE__) -#include "ace/ATM_QoS.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) -#define BHLI_MAGIC "FORE_ATM" -// This is line rate in cells/s for an OC-3 MM interface. -const long ACE_ATM_QoS::LINE_RATE = 353207; -const int ACE_ATM_QoS::OPT_FLAGS_CPID = 0x1; -const int ACE_ATM_QoS::OPT_FLAGS_PMP = 0x2; -const int ACE_ATM_QoS::DEFAULT_SELECTOR = 0x99; -const int ACE_ATM_QoS::DEFAULT_PKT_SIZE = 8192; -#elif defined (ACE_HAS_LINUX_ATM) -//pbrandao:for Linux: -//pbrandao:for now stick with current definitions -//pbrandao:see if later need to change -const long ACE_ATM_QoS::LINE_RATE = 353207; -const int ACE_ATM_QoS::OPT_FLAGS_CPID = 0x1; -const int ACE_ATM_QoS::OPT_FLAGS_PMP = 0x2; -const int ACE_ATM_QoS::DEFAULT_SELECTOR = 0x99; -const int ACE_ATM_QoS::DEFAULT_PKT_SIZE = 8192; -#else -const long ACE_ATM_QoS::LINE_RATE = 0L; -const int ACE_ATM_QoS::OPT_FLAGS_CPID = 0; -const int ACE_ATM_QoS::OPT_FLAGS_PMP = 0; -const int ACE_ATM_QoS::DEFAULT_SELECTOR = 0x0; -const int ACE_ATM_QoS::DEFAULT_PKT_SIZE = 0; -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ - -ACE_ALLOC_HOOK_DEFINE(ACE_ATM_QoS) - -ACE_ATM_QoS::ACE_ATM_QoS (int pktSize) -{ - ACE_TRACE ("ACE_ATM_QoS::ACE_ATM_QoS"); -#if defined (ACE_HAS_LINUX_ATM) - ACE_OS::memset(&qos_, 0, sizeof(qos_)); - qos_.aal = ATM_PROTOCOL_DEFAULT; - qos_.rxtp.traffic_class = ATM_ANYCLASS; - qos_.rxtp.max_sdu = pktSize; - qos_.txtp.traffic_class = ATM_ANYCLASS; - qos_.txtp.max_sdu = pktSize; -#else - ACE_UNUSED_ARG (pktSize); -#endif /* ACE_HAS_LINUX_ATM */ -} - -ACE_ATM_QoS::ACE_ATM_QoS(int rate, - int pktSize) -{ - ACE_TRACE( "ACE_ATM_QoS::ACE_ATM_QoS" ); -#if defined (ACE_HAS_FORE_ATM_WS2) - AAL_PARAMETERS_IE ie_aalparams; - ATM_TRAFFIC_DESCRIPTOR_IE ie_td; - ATM_BROADBAND_BEARER_CAPABILITY_IE ie_bbc; - ATM_QOS_CLASS_IE ie_qos; - Q2931_IE *ie_ptr; - int size; - - // Setting up cbr parameters ... - ie_aalparams.AALType = AALTYPE_5; - ie_aalparams.AALSpecificParameters.AAL5Parameters.ForwardMaxCPCSSDUSize - = pktSize; // was 1516; - ie_aalparams.AALSpecificParameters.AAL5Parameters.BackwardMaxCPCSSDUSize - = pktSize; // was 1516; - ie_aalparams.AALSpecificParameters.AAL5Parameters.Mode = AAL5_MODE_MESSAGE; - ie_aalparams.AALSpecificParameters.AAL5Parameters.SSCSType = AAL5_SSCS_NULL; - - size = sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + sizeof(AAL_PARAMETERS_IE); - - ie_td.Forward.PeakCellRate_CLP0 = SAP_FIELD_ABSENT; - ie_td.Forward.PeakCellRate_CLP01 = rate; - ie_td.Forward.SustainableCellRate_CLP0 = SAP_FIELD_ABSENT; - ie_td.Forward.SustainableCellRate_CLP01 = SAP_FIELD_ABSENT; - ie_td.Forward.MaxBurstSize_CLP0 = SAP_FIELD_ABSENT; - ie_td.Forward.MaxBurstSize_CLP01 = SAP_FIELD_ABSENT; - ie_td.Forward.Tagging = SAP_FIELD_ABSENT; - - ie_td.Backward.PeakCellRate_CLP0 = SAP_FIELD_ABSENT; - ie_td.Backward.PeakCellRate_CLP01 = rate; - ie_td.Backward.SustainableCellRate_CLP0 = SAP_FIELD_ABSENT; - ie_td.Backward.SustainableCellRate_CLP01 = SAP_FIELD_ABSENT; - ie_td.Backward.MaxBurstSize_CLP0 = SAP_FIELD_ABSENT; - ie_td.Backward.MaxBurstSize_CLP01 = SAP_FIELD_ABSENT; - ie_td.Backward.Tagging = SAP_FIELD_ABSENT; - - ie_td.BestEffort = 0; // Note: this must be set to zero for CBR. - - size += sizeof( Q2931_IE_TYPE ) - + sizeof( ULONG ) - + sizeof( ATM_TRAFFIC_DESCRIPTOR_IE ); - - ie_bbc.BearerClass = BCOB_X; - ie_bbc.TrafficType = TT_CBR; - ie_bbc.TimingRequirements = TR_END_TO_END; - ie_bbc.ClippingSusceptability = CLIP_NOT; - ie_bbc.UserPlaneConnectionConfig = UP_P2P; - - size += sizeof( Q2931_IE_TYPE ) - + sizeof( ULONG ) - + sizeof( ATM_BROADBAND_BEARER_CAPABILITY_IE ); - - ie_qos.QOSClassForward = QOS_CLASS1; - ie_qos.QOSClassBackward = QOS_CLASS1; // This may not be really used - // since we do only simplex data xfer. - - size += sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + sizeof(ATM_QOS_CLASS_IE); - - qos_.ProviderSpecific.buf = (char *) ACE_OS::malloc(size); - if (qos_.ProviderSpecific.buf == 0) { - ACELIB_ERROR((LM_ERROR, - ACE_TEXT ("ACE_ATM_QoS::ACE_ATM_QoS: Unable to allocate %d bytes for qos_.ProviderSpecific.buf\n"), - size)); - return; - } - qos_.ProviderSpecific.len = size; - ACE_OS::memset(qos_.ProviderSpecific.buf, 0, size); - - ie_ptr = (Q2931_IE *) qos_.ProviderSpecific.buf; - ie_ptr->IEType = IE_AALParameters; - ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) - + sizeof( ULONG ) - + sizeof( AAL_PARAMETERS_IE ); - ACE_OS::memcpy(ie_ptr->IE, &ie_aalparams, sizeof(AAL_PARAMETERS_IE)); - - ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength); - ie_ptr->IEType = IE_TrafficDescriptor; - ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) - + sizeof( ULONG ) - + sizeof( ATM_TRAFFIC_DESCRIPTOR_IE ); - ACE_OS::memcpy(ie_ptr->IE, &ie_td, sizeof(ATM_TRAFFIC_DESCRIPTOR_IE)); - - ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength); - ie_ptr->IEType = IE_BroadbandBearerCapability; - ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) - + sizeof( ULONG ) - + sizeof( ATM_BROADBAND_BEARER_CAPABILITY_IE ); - ACE_OS::memcpy(ie_ptr->IE, - &ie_bbc, - sizeof(ATM_BROADBAND_BEARER_CAPABILITY_IE)); - - ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength); - ie_ptr->IEType = IE_QOSClass; - ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) - + sizeof( ULONG ) - + sizeof( ATM_QOS_CLASS_IE ); - ACE_OS::memcpy(ie_ptr->IE, &ie_qos, sizeof(ATM_QOS_CLASS_IE)); - - // qos_.SendingFlowspec.TokenRate = 0xffffffff; - // qos_.SendingFlowspec.TokenBucketSize = 0xffffffff; - // qos_.SendingFlowspec.PeakBandwidth = 0xffffffff; - // qos_.SendingFlowspec.Latency = 0xffffffff; - // qos_.SendingFlowspec.DelayVariation = 0xffffffff; - // qos_.SendingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT; - // This will most probably be ignored by the service provider. - // qos_.SendingFlowspec.MaxSduSize = 0xffffffff; - // qos_.SendingFlowspec.MinimumPolicedSize = 0xffffffff; - - // qos_.ReceivingFlowspec.TokenRate = 0xffffffff; - // qos_.ReceivingFlowspec.TokenBucketSize = 0xffffffff; - // qos_.ReceivingFlowspec.PeakBandwidth = 0xffffffff; - // qos_.ReceivingFlowspec.Latency = 0xffffffff; - // qos_.ReceivingFlowspec.DelayVariation = 0xffffffff; - // qos_.ReceivingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT; - // This will most probably be ignored by the service provider. - // qos_.ReceivingFlowspec.MaxSduSize = 0xffffffff; - // qos_.ReceivingFlowspec.MinimumPolicedSize = 0; - - ACE_Flow_Spec send_fspec( 0xffffffff, - 0xffffffff, - 0xffffffff, - 0xffffffff, - 0xffffffff, - SERVICETYPE_BESTEFFORT, - // This will most probably ignored by SP. - 0xffffffff, - 0xffffffff, - 15, - ACE_DEFAULT_THREAD_PRIORITY ), - recv_fspec( 0xffffffff, - 0xffffffff, - 0xffffffff, - 0xffffffff, - 0xffffffff, - SERVICETYPE_BESTEFFORT, - // This will most probably ignored by SP. - 0xffffffff, - 0, - 15, - ACE_DEFAULT_THREAD_PRIORITY ); - - qos_.sending_flowspec (send_fspec); - qos_.receiving_flowspec (recv_fspec); -#elif defined (ACE_HAS_FORE_ATM_XTI) - ACE_UNUSED_ARG (rate); - ACE_UNUSED_ARG (pktSize); -#elif defined (ACE_HAS_LINUX_ATM) - ACE_OS::memset(&qos_, - 0, - sizeof(qos_)); - qos_.aal = ATM_PROTOCOL_DEFAULT; - qos_.rxtp.max_sdu = pktSize; - - if (rate > 0) { - qos_.rxtp.pcr = rate; - qos_.rxtp.traffic_class = ATM_CBR; - qos_.txtp.traffic_class = ATM_CBR; - qos_.txtp.pcr = rate; - } - else { - qos_.rxtp.traffic_class = ATM_UBR; - qos_.txtp.traffic_class = ATM_UBR; - } - - qos_.txtp.max_sdu = pktSize; -#else - ACE_UNUSED_ARG (rate); -#endif /* ACE_HAS_FORE_ATM_WS2 || ACE_HAS_FORE_ATM_XTI || ACE_HAS_LINUX_ATM */ -} - -void -ACE_ATM_QoS::set_cbr_rate (int rate, - int pktSize) -{ - ACE_TRACE ("ACE_ATM_QoS::set_cbr_rate"); -#if defined (ACE_HAS_FORE_ATM_WS2) - /* - AAL_PARAMETERS_IE ie_aalparams; - ATM_TRAFFIC_DESCRIPTOR_IE ie_td; - ATM_BROADBAND_BEARER_CAPABILITY_IE ie_bbc; - ATM_QOS_CLASS_IE ie_qos; - Q2931_IE *ie_ptr; - int size; - */ - - ACE_OS::printf( "ATM_QoS(set_cbr_rate): set rate to %d c/s\n", rate ); - - // Setting up cbr parameters ... - /* - FORE has changed this - we no longer specify QoS this way - ie_aalparams.AALType = AALTYPE_5; - ie_aalparams.AALSpecificParameters.AAL5Parameters.ForwardMaxCPCSSDUSize - = pktSize; // was 1516; - ie_aalparams.AALSpecificParameters.AAL5Parameters.BackwardMaxCPCSSDUSize - = pktSize; // was 1516; - ie_aalparams.AALSpecificParameters.AAL5Parameters.Mode = AAL5_MODE_MESSAGE; - ie_aalparams.AALSpecificParameters.AAL5Parameters.SSCSType = AAL5_SSCS_NULL; - - size = sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + sizeof(AAL_PARAMETERS_IE); - - ie_td.Forward.PeakCellRate_CLP0 = SAP_FIELD_ABSENT; - ie_td.Forward.PeakCellRate_CLP01 = rate; - ie_td.Forward.SustainableCellRate_CLP0 = SAP_FIELD_ABSENT; - ie_td.Forward.SustainableCellRate_CLP01 = SAP_FIELD_ABSENT; - ie_td.Forward.MaxBurstSize_CLP0 = SAP_FIELD_ABSENT; - ie_td.Forward.MaxBurstSize_CLP01 = SAP_FIELD_ABSENT; - ie_td.Forward.Tagging = SAP_FIELD_ABSENT; - - ie_td.Backward.PeakCellRate_CLP0 = SAP_FIELD_ABSENT; - ie_td.Backward.PeakCellRate_CLP01 = rate; - ie_td.Backward.SustainableCellRate_CLP0 = SAP_FIELD_ABSENT; - ie_td.Backward.SustainableCellRate_CLP01 = SAP_FIELD_ABSENT; - ie_td.Backward.MaxBurstSize_CLP0 = SAP_FIELD_ABSENT; - ie_td.Backward.MaxBurstSize_CLP01 = SAP_FIELD_ABSENT; - ie_td.Backward.Tagging = SAP_FIELD_ABSENT; - - ie_td.BestEffort = 0; // Note: this must be set to zero for CBR. - - size += sizeof( Q2931_IE_TYPE ) + - sizeof( ULONG ) + - sizeof( ATM_TRAFFIC_DESCRIPTOR_IE ); - - ie_bbc.BearerClass = BCOB_X; - ie_bbc.TrafficType = TT_CBR; - ie_bbc.TimingRequirements = TR_END_TO_END; - ie_bbc.ClippingSusceptability = CLIP_NOT; - ie_bbc.UserPlaneConnectionConfig = UP_P2P; - - size += sizeof(Q2931_IE_TYPE) + - sizeof(ULONG) + - sizeof(ATM_BROADBAND_BEARER_CAPABILITY_IE); - - ie_qos.QOSClassForward = QOS_CLASS1; - ie_qos.QOSClassBackward = QOS_CLASS1; // This may not be really used - // since we only simplex data xfer. - - size += sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + sizeof(ATM_QOS_CLASS_IE); - - qos_.ProviderSpecific.buf = (char *) ACE_OS::malloc(size); - if (qos_.ProviderSpecific.buf == 0) { - ACELIB_ERROR((LM_ERROR, - ACE_TEXT ("ACE_ATM_QoS::ACE_ATM_QoS: Unable to allocate %d bytes for qos_.ProviderSpecific.buf\n"), - size)); - return; - } - qos_.ProviderSpecific.len = size; - ACE_OS::memset(qos_.ProviderSpecific.buf, 0, size); - - ie_ptr = (Q2931_IE *) qos_.ProviderSpecific.buf; - ie_ptr->IEType = IE_AALParameters; - ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) + - sizeof( ULONG ) + - sizeof( AAL_PARAMETERS_IE ); - ACE_OS::memcpy(ie_ptr->IE, &ie_aalparams, sizeof(AAL_PARAMETERS_IE)); - - ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength); - ie_ptr->IEType = IE_TrafficDescriptor; - ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) + - sizeof( ULONG ) + - sizeof( ATM_TRAFFIC_DESCRIPTOR_IE ); - ACE_OS::memcpy(ie_ptr->IE, &ie_td, sizeof(ATM_TRAFFIC_DESCRIPTOR_IE)); - - ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength); - ie_ptr->IEType = IE_BroadbandBearerCapability; - ie_ptr->IELength = sizeof( Q2931_IE_TYPE ) + - sizeof( ULONG ) + - sizeof( ATM_BROADBAND_BEARER_CAPABILITY_IE ); - ACE_OS::memcpy( ie_ptr->IE, - &ie_bbc, - sizeof( ATM_BROADBAND_BEARER_CAPABILITY_IE )); - - ie_ptr = (Q2931_IE *) ((char *)ie_ptr + ie_ptr->IELength); - ie_ptr->IEType = IE_QOSClass; - ie_ptr->IELength = sizeof(Q2931_IE_TYPE) + sizeof(ULONG) + - sizeof(ATM_QOS_CLASS_IE); - ACE_OS::memcpy(ie_ptr->IE, &ie_qos, sizeof(ATM_QOS_CLASS_IE)); - */ - - const int BYTES_PER_ATM_CELL = 53; - ACE_OS::memset(&qos_, 0, sizeof(ATM_QoS)); - // Setting the token rate sets the minimum rate. 3 Mbits/sec seems too high. - // Certainly for Vaudeville audio, we only need about 1000 c/s which is - // 424000 bits/sec which is 53000 bytes/sec. - //qos_.SendingFlowspec.TokenRate = 3*(1024*128); // 3Mbits/sec - qos_.SendingFlowspec.TokenRate = 53000; // 1000 cells/sec - qos_.SendingFlowspec.TokenBucketSize = 32*1024; // our block size - //ourQos.SendingFlowspec.PeakBandwidth = ourQos.SendingFlowspec.TokenRate; - qos_.SendingFlowspec.ServiceType = SERVICETYPE_GUARANTEED; - // Peak bandwidth is in bytes/sec. The rate is specified in cells/sec so - // we need to convert from cells/sec to bytes/sec (i.e., multiply by 53). - qos_.SendingFlowspec.PeakBandwidth = rate * BYTES_PER_ATM_CELL; - qos_.SendingFlowspec.Latency = -1; // we don't care too much - qos_.SendingFlowspec.DelayVariation = -1; // we don't care too much - // no provider-specific data allowed on ATM - qos_.ProviderSpecific.buf=0; - qos_.ProviderSpecific.len=0; - // unidirectional P2MP; we don't need to setup the Receiving flowspec - - //qos_.SendingFlowspec.TokenRate = 0xffffffff; - //qos_.SendingFlowspec.TokenBucketSize = 0xffffffff; - //qos_.SendingFlowspec.PeakBandwidth = 0xffffffff; - //qos_.SendingFlowspec.Latency = 0xffffffff; - //qos_.SendingFlowspec.DelayVariation = 0xffffffff; - //qos_.SendingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT; - // This will most probably be ignored by the service provider. - //qos_.SendingFlowspec.MaxSduSize = 0xffffffff; - //qos_.SendingFlowspec.MinimumPolicedSize = 0xffffffff; - - //qos_.ReceivingFlowspec.TokenRate = 0xffffffff; - //qos_.ReceivingFlowspec.TokenBucketSize = 0xffffffff; - //qos_.ReceivingFlowspec.PeakBandwidth = 0xffffffff; - //qos_.ReceivingFlowspec.Latency = 0xffffffff; - //qos_.ReceivingFlowspec.DelayVariation = 0xffffffff; - //qos_.ReceivingFlowspec.ServiceType = SERVICETYPE_BESTEFFORT; - // This will most probably be ignored by the service provider. - //qos_.ReceivingFlowspec.MaxSduSize = 0xffffffff; - //qos_.ReceivingFlowspec.MinimumPolicedSize = 0; - - /* - ACE_Flow_Spec send_fspec( 0xffffffff, - 0xffffffff, - 0xffffffff, - 0xffffffff, - 0xffffffff, - SERVICETYPE_BESTEFFORT, - // This will most probably ignored by SP. - 0xffffffff, - 0xffffffff, - 15, - ACE_DEFAULT_THREAD_PRIORITY ), - recv_fspec( 0xffffffff, - 0xffffffff, - 0xffffffff, - 0xffffffff, - 0xffffffff, - SERVICETYPE_BESTEFFORT, - // This will most probably ignored by SP. - 0xffffffff, - 0, - 15, - ACE_DEFAULT_THREAD_PRIORITY ); - - qos_.sending_flowspec( send_fspec ); - qos_.receiving_flowspec( recv_fspec ); - */ -#elif defined (ACE_HAS_FORE_ATM_XTI) - ACE_UNUSED_ARG (rate); - ACE_UNUSED_ARG (pktSize); -#elif defined (ACE_HAS_LINUX_ATM) - ACE_UNUSED_ARG (pktSize); - - qos_.rxtp.traffic_class = ATM_CBR; - qos_.rxtp.pcr = rate; - qos_.txtp.traffic_class = ATM_CBR; - qos_.txtp.pcr = rate; -#else - ACE_UNUSED_ARG (rate); -#endif /* ACE_HAS_FORE_ATM_WS2 || ACE_HAS_FORE_ATM_XTI || ACE_HAS_LINUX_ATM */ -} - -void -ACE_ATM_QoS::set_rate (ACE_HANDLE fd, - int rate, - int flags) -{ - ACE_TRACE ("ACE_ATM_QoS::set_rate"); -#if defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM) - set_cbr_rate( rate ); - - ACE_UNUSED_ARG( fd ); - ACE_UNUSED_ARG( flags ); -#elif defined (ACE_HAS_FORE_ATM_XTI) - long optlen = 0; - qos_.buf = construct_options(fd, - rate, - flags, - &optlen); - qos_.len = optlen; -#else - ACE_UNUSED_ARG (rate); -#endif /* ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM || ACE_HAS_FORE_ATM_XTI */ -} - -char* -ACE_ATM_QoS::construct_options (ACE_HANDLE fd, - int rate, - int flags, - long *len) -{ -#if defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM) - ACE_UNUSED_ARG (fd); - ACE_UNUSED_ARG (rate); - ACE_UNUSED_ARG (flags); - ACE_UNUSED_ARG (len); - return 0; -#elif defined (ACE_HAS_FORE_ATM_XTI) - struct t_opthdr *popt; - char *buf; - int qos_cells; - struct t_info info; - - if (ACE_OS::t_getinfo (fd, &info) == -1) - { - ACE_OS::t_error ("t_getinfo"); - return 0; - } - - buf = (char *) ACE_OS::malloc (info.options); - - if (buf == 0) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("Unable to allocate %d bytes for options\n"), - info.options), - 0); - - popt = (struct t_opthdr *) buf; - - if (flags & OPT_FLAGS_CPID) - { - // This constructs the T_ATM_ORIG_ADDR option, which is used to - // signal the UNI 3.1 Calling Party ID Information Element. - t_atm_addr *source_addr; - - popt->len = sizeof (struct t_opthdr) + sizeof (t_atm_addr); - popt->level = T_ATM_SIGNALING; - popt->name = T_ATM_ORIG_ADDR; - popt->status = 0; - - source_addr = - (t_atm_addr *)((char *) popt + sizeof (struct t_opthdr)); - - source_addr->address_format = T_ATM_ENDSYS_ADDR; - source_addr->address_length = ATMNSAP_ADDR_LEN; - - ATMSAPAddress local_addr; - struct t_bind boundaddr; - - boundaddr.addr.maxlen = sizeof(local_addr); - boundaddr.addr.buf = (char *) &local_addr; - - //if (ACE_OS::t_getprotaddr(fd, &boundaddr, 0) < 0) { - if (ACE_OS::t_getname(fd, - &boundaddr.addr, - LOCALNAME) < 0) - { - ACE_OS::t_error("t_getname (local_address)"); - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("Can't get local address!\n"))); - ACE_OS::free (buf); - return 0; - } - - ACE_OS::memcpy(source_addr->address, - local_addr.sap.t_atm_sap_addr.address, - ATMNSAP_ADDR_LEN); - - popt = T_OPT_NEXTHDR (buf, info.options , popt); - } - - // This constructs all options necessary (bearer cap., QoS, and - // Traffic Descriptor) to signal for a CBR connection with the - // specified QoS in kbit/sec., and/or specify a PMP connection. - - // For FORE 200e cards, the adapter shapes traffic to CBR with rate - // equal to PCR CLP=0+1 (traffic.forward.PCR_all_traffic) - - qos_cells = (rate * 1000) / (48*8); - - if ((qos_cells > 0 && qos_cells < LINE_RATE) - || (ACE_BIT_ENABLED (flags, OPT_FLAGS_PMP))) - { - struct t_atm_bearer *bearer; - struct t_atm_traffic *traffic; - - // T_ATM_BEARER_CAP: Broadband bearer capability - popt->len = sizeof (struct t_opthdr) + sizeof (struct t_atm_bearer); - popt->level = T_ATM_SIGNALING; - popt->name = T_ATM_BEARER_CAP; - popt->status = 0; - - bearer = (struct t_atm_bearer *)((char *) popt + - sizeof (struct t_opthdr)); - bearer->bearer_class = T_ATM_CLASS_X; - - if (qos_cells) - { - bearer->traffic_type = T_ATM_CBR; - bearer->timing_requirements = T_ATM_END_TO_END; - } - else - { - bearer->traffic_type = 0; // UBR - bearer->timing_requirements = 0; - } - bearer->clipping_susceptibility = T_ATM_NULL; - - if (ACE_BIT_ENABLED (flags, OPT_FLAGS_PMP)) - bearer->connection_configuration = T_ATM_1_TO_MANY; - else - bearer->connection_configuration = T_ATM_1_TO_1; - - popt = T_OPT_NEXTHDR (buf, info.options, popt); - - // T_ATM_TRAFFIC: traffic descriptor - popt->len = sizeof (struct t_opthdr) + sizeof (struct t_atm_traffic); - popt->level = T_ATM_SIGNALING; - popt->name = T_ATM_TRAFFIC; - popt->status = 0; - - traffic = (struct t_atm_traffic *)((char *) popt + - sizeof (struct t_opthdr)); - - traffic->forward.PCR_high_priority = T_ATM_ABSENT; - traffic->forward.PCR_all_traffic = qos_cells ? qos_cells : LINE_RATE; - traffic->forward.SCR_high_priority = T_ATM_ABSENT; - traffic->forward.SCR_all_traffic = T_ATM_ABSENT; - traffic->forward.MBS_high_priority = T_ATM_ABSENT; - traffic->forward.MBS_all_traffic = T_ATM_ABSENT; - traffic->forward.tagging = T_NO; - - traffic->backward.PCR_high_priority = T_ATM_ABSENT; - traffic->backward.PCR_all_traffic = - (ACE_BIT_ENABLED (flags, OPT_FLAGS_PMP)) - ? 0 : qos_cells ? qos_cells : LINE_RATE; - traffic->backward.SCR_high_priority = T_ATM_ABSENT; - traffic->backward.SCR_all_traffic = T_ATM_ABSENT; - traffic->backward.MBS_high_priority = T_ATM_ABSENT; - traffic->backward.MBS_all_traffic = T_ATM_ABSENT; - traffic->backward.tagging = T_NO; - - traffic->best_effort = qos_cells ? T_NO : T_YES; - - popt = T_OPT_NEXTHDR (buf, - info.options, - popt); - } - - if (qos_cells > 0 && qos_cells < LINE_RATE) - { - struct t_atm_qos *qos; - - // T_ATM_QOS: Quality of Service - popt->len = sizeof (struct t_opthdr) + sizeof (struct t_atm_qos); - popt->level = T_ATM_SIGNALING; - popt->name = T_ATM_QOS; - popt->status = 0; - - qos = (struct t_atm_qos *)((char *) popt + sizeof (struct t_opthdr)); - qos->coding_standard = T_ATM_ITU_CODING; - qos->forward.qos_class = T_ATM_QOS_CLASS_1; - qos->backward.qos_class = T_ATM_QOS_CLASS_1; - - popt = T_OPT_NEXTHDR (buf, info.options, popt); - } - - // Return actual size of options and option buffer to user. - *len = (char *) popt - buf; - - return buf; -#else - ACE_UNUSED_ARG (fd); - ACE_UNUSED_ARG (rate); - ACE_UNUSED_ARG (flag); - ACE_UNUSED_ARG (len); - return 0; -#endif /* ACE_HAS_FORE_ATM_WS2 */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_ATM */ - diff --git a/deps/acelite/ace/ATM_QoS.h b/deps/acelite/ace/ATM_QoS.h deleted file mode 100644 index 1417a5d0f..000000000 --- a/deps/acelite/ace/ATM_QoS.h +++ /dev/null @@ -1,111 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file ATM_QoS.h - * - * @author Joe Hoffert - */ -//========================================================================== - -#ifndef ACE_ATM_QoS_H -#define ACE_ATM_QoS_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined(ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_ATM) - -#if defined (ACE_HAS_FORE_ATM_WS2) -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -// just map to WS2 GQOS struct -typedef ACE_QoS ATM_QoS; -ACE_END_VERSIONED_NAMESPACE_DECL -#elif defined (ACE_HAS_FORE_ATM_XTI) -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -typedef struct netbuf ATM_QoS; -ACE_END_VERSIONED_NAMESPACE_DECL -#elif defined (ACE_HAS_LINUX_ATM) -#include /**/ "atm.h" -#include "ace/ATM_Params.h" -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -typedef struct atm_qos ATM_QoS; -ACE_END_VERSIONED_NAMESPACE_DECL -#else -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -typedef int ATM_QoS; -ACE_END_VERSIONED_NAMESPACE_DECL -#endif /* ACE_HAS_FORE_ATM_WS2 || ACE_HAS_FORE_ATM_XTI || ACE_HAS_LINUX_ATM */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_ATM_QoS - * - * @brief Define the QoS parameters for ATM - * - * This class wraps up QoS parameters for both ATM/XTI and - * ATM/WinSock2 to make the mechanism for the ATM protocol - * transparent. - */ -class ACE_Export ACE_ATM_QoS -{ -public: - // Constants used for ATM options - static const long LINE_RATE; - static const int OPT_FLAGS_CPID; - static const int OPT_FLAGS_PMP; - static const int DEFAULT_SELECTOR; - static const int DEFAULT_PKT_SIZE; - - /// Default constructor. - ACE_ATM_QoS(int = DEFAULT_PKT_SIZE); - - /// Constructor with a CBR rate. - ACE_ATM_QoS(int, - int = DEFAULT_PKT_SIZE); - - ~ACE_ATM_QoS (); - - /// Set the rate. - void set_rate (ACE_HANDLE, - int, - int); - - /// Set CBR rate in cells per second. - void set_cbr_rate (int, - int = DEFAULT_PKT_SIZE); - - /// Get ATM_QoS struct. - ATM_QoS get_qos (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Construct QoS options. - char* construct_options(ACE_HANDLE, - int, - int, - long*); - -private: - ATM_QoS qos_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/ATM_QoS.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* ACE_HAS_ATM */ -#include /**/ "ace/post.h" -#endif /* ACE_ATM_QoS_H */ diff --git a/deps/acelite/ace/ATM_QoS.inl b/deps/acelite/ace/ATM_QoS.inl deleted file mode 100644 index 479079e99..000000000 --- a/deps/acelite/ace/ATM_QoS.inl +++ /dev/null @@ -1,26 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE void -ACE_ATM_QoS::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_ATM_QoS::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_INLINE -ACE_ATM_QoS::~ACE_ATM_QoS () -{ - ACE_TRACE ("ACE_ATM_QoS::~ACE_ATM_QoS"); -} - -ACE_INLINE -ATM_QoS -ACE_ATM_QoS::get_qos (void) -{ - ACE_TRACE ("ACE_ATM_QoS::get_qos"); - return qos_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/ATM_Stream.cpp b/deps/acelite/ace/ATM_Stream.cpp deleted file mode 100644 index f87ac4def..000000000 --- a/deps/acelite/ace/ATM_Stream.cpp +++ /dev/null @@ -1,288 +0,0 @@ -#include "ace/ATM_Stream.h" - -#if defined (ACE_HAS_ATM) - -#include "ace/OS_NS_string.h" - -#if !defined (__ACE_INLINE__) -#include "ace/ATM_Stream.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE (ACE_ATM_Stream) - -char* -ACE_ATM_Stream::get_peer_name (void) const -{ - ACE_TRACE ("ACE_ATM_Stream::get_peer_name"); -#if defined (ACE_HAS_FORE_ATM_XTI) - // // Use t_getprotaddr for XTI/ATM - // struct t_bind *localaddr - // = (struct t_bind *) ACE_OS::t_alloc (get_handle (), - // T_BIND, - // T_ADDR); - // struct t_bind *peeraddr - // = (struct t_bind *) ACE_OS::t_alloc (get_handle (), - // T_BIND, - // T_ADDR); - // ::t_getprotaddr (get_handle (), - // localaddr, - // peeraddr); - - // char* connected_name = (char*) ACE_OS::malloc (peeraddr->addr.len + 1); - // ACE_OS::strcpy (connected_name, - // peeraddr->addr.buf); - // ACE_OS::t_free ((char *) localaddr, - // T_BIND); - // ACE_OS::t_free ((char *) peeraddr, - // T_BIND); - // return (connected_name); - -#error "This doesn't seem to work. May need to jimmy-rig something with the" -#error "/etc/xti_hosts file - Ugh!" - - ACE_ATM_Addr sa; - struct netbuf name; - name.maxlen = sa.get_size (); - name.buf = (char *) sa.get_addr (); - ACE_OS::t_getname (this->get_handle (), &name, REMOTENAME); - // ACE_OS::ioctl (this->get_handle (), - // TI_GETPEERNAME, - // &name); - return (name.buf); - -#elif defined (ACE_HAS_FORE_ATM_WS2) - // Use getpeername for WinSock2. - struct sockaddr_atm name; - ACE_OS::memset (&name, 0, sizeof (name)); - int nameSize = sizeof (name); - - if (ACE_OS::getpeername (this->get_handle (), - (struct sockaddr *) &name, - &nameSize) != 0) { - return 0; - } - - char buffer[256]; - for (unsigned int index = 0; index < ATM_ADDR_SIZE - 1; index++) { - buffer[ index * 3 ] = '\0'; - ACE_OS::sprintf (buffer, "%s%02x.", buffer, name.satm_number.Addr[ index ]); - } - buffer[ (ATM_ADDR_SIZE - 1) * 3 ] = '\0'; - ACE_OS::sprintf (buffer, "%s%02x.", buffer, 0); - buffer[ ATM_ADDR_SIZE * 3 - 1 ] = '\0'; - for (index = 0; index < ACE_OS::strlen (buffer); ++index) - buffer[index] = ACE_OS::ace_tolower (buffer[index]); - - ifstream atm_hosts ("C:/WINNT/atmhosts"); - assert (atm_hosts.is_open ()); - - // Find the host address in the ATM hosts file and return the - // host name - char line[256]; - char *host_ptr, *host_name = 0; - ACE_NEW_RETURN (host_name, char[256], 0); - while (!atm_hosts.eof ()) { - atm_hosts.getline (line, 256); - // Convert the line to lower case to ease comparison - for (index = 0; index < ACE_OS::strlen (line); ++index) - line[index] = ACE_OS::ace_tolower (line[index]); - if (ACE_OS::strstr (line, buffer) != 0) - { - char *strtok_p; - // Grab the second token which is the host name - ACE_OS::strtok_r (line, " \t", &strtok_p); - host_ptr = ACE_OS::strtok (0, " \t", &strtok_p); - ACE_OS::strcpy (host_name, host_ptr); - break; - } - } - - return host_name; -#elif defined (ACE_HAS_LINUX_ATM) - ATM_Addr name; - int nameSize = sizeof (name.sockaddratmsvc); - - if (ACE_OS::getpeername (this->get_handle (), - (struct sockaddr *) & (name.sockaddratmsvc), - &nameSize) < 0) { - ACE_OS::perror ("ACE_ATM_Stream (get_peer_name) : "); - return 0; - } - - static ACE_TCHAR buffer[MAX_ATM_ADDR_LEN + 1]; - int total_len; - if ((total_len = atm2text (buffer,sizeof buffer, - (struct sockaddr *) & (name.sockaddratmsvc), - A2T_PRETTY|A2T_NAME)) < 0) { - ACELIB_DEBUG ((LM_DEBUG,ACE_TEXT ("ACE_ATM_Stream (get_peer_name) :%d"),errno)); - return 0; - } - - return (char*) buffer; -#else - return 0; -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ -} - -ACE_HANDLE -ACE_ATM_Stream::get_handle (void) const -{ - ACE_TRACE ("ACE_ATM_Stream::get_handle"); -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) || defined (ACE_HAS_LINUX_ATM) - return stream_.get_handle (); -#else - return 0; -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ -} - -int -ACE_ATM_Stream::get_vpi_vci (ACE_UINT16 &vpi, - ACE_UINT16 &vci) const -{ - ACE_TRACE ("ACE_ATM_Stream::get_vpi_vci"); -#if defined (ACE_HAS_FORE_ATM_XTI) - struct t_atm_conn_prop conn_prop; - char* connect_opts = (char *) &conn_prop; - int opt_size = sizeof (t_atm_conn_prop); - struct t_info info; - struct t_optmgmt opt_req, opt_ret; - - if (ACE_OS::t_getinfo (stream_.get_handle (), - &info) < 0) - { - ACE_OS::t_error ("t_getinfo"); - return -1; - } - - char *buf_req = (char *) ACE_OS::malloc (info.options); - if (buf_req == 0) - { - ACE_OS::fprintf (stderr, - "Unable to allocate %ld bytes for options\n", - info.options); - return -1; - } - - char *buf_ret = (char *) ACE_OS::malloc (info.options); - if (buf_ret == 0) - { - ACE_OS::fprintf (stderr, - "Unable to allocate %ld bytes for options\n", - info.options); - return -1; - } - - ACE_OS::memset (&opt_req, 0, sizeof (opt_req)); - ACE_OS::memset (&opt_ret, 0, sizeof (opt_ret)); - - struct t_opthdr *popt = (struct t_opthdr *) buf_req; - struct t_opthdr *popt_ret = (struct t_opthdr *) buf_ret; - - popt->len= sizeof (struct t_opthdr) + opt_size; - - // We are only concerned with SVCs so no other check or values are needed - // here. - popt->level = T_ATM_SIGNALING; - popt->name = T_ATM_CONN_PROP; - popt->status = 0; - - opt_req.opt.len = popt->len; - opt_req.opt.buf = (char *) popt; - opt_req.flags = T_CURRENT; - - popt = T_OPT_NEXTHDR (buf_req, - info.options, - popt); - opt_ret.opt.maxlen = info.options; - opt_ret.opt.buf = (char *) popt_ret; - - if (ACE_OS::t_optmgmt (stream_.get_handle (), - &opt_req, - &opt_ret) < 0) { - ACE_OS::t_error ("t_optmgmt"); - return -1; - } - - ACE_OS::memcpy (connect_opts, - (char *) popt_ret + sizeof (struct t_opthdr), - opt_size); - - ACE_OS::free (buf_ret); - ACE_OS::free (buf_req); - - vpi = conn_prop.vpi; - vci = conn_prop.vci; - return 0; -#elif defined (ACE_HAS_FORE_ATM_WS2) - ATM_CONNECTION_ID connID; - DWORD bytes = 0; - - if (::WSAIoctl ((int) this -> get_handle (), - SIO_GET_ATM_CONNECTION_ID, - 0, - 0, - (LPVOID) &connID, - sizeof (ATM_CONNECTION_ID), - &bytes, - 0, - 0) - == SOCKET_ERROR) { - ACE_OS::printf ("Error: WSAIoctl %d\n", WSAGetLastError ()); - } - - vpi = (ACE_UINT16) connID.VPI; - vci = (ACE_UINT16) connID.VCI; - - return 0; -#elif defined (ACE_HAS_LINUX_ATM) -#if defined (SO_ATMPVC) /* atm version>=0.62 */ - struct sockaddr_atmpvc mypvcaddr; - int addrpvclen = sizeof (mypvcaddr); - if (ACE_OS::getsockopt (stream_.get_handle (), - SOL_ATM, - SO_ATMPVC, - reinterpret_cast (&mypvcaddr), - &addrpvclen) < 0) { - ACELIB_DEBUG (LM_DEBUG, - ACE_TEXT ("ACE_ATM_Stream::get_vpi_vci: getsockopt %d\n"), - errno); - return -1; - } - vpi = (ACE_UINT16) mypvcaddr.sap_addr.vpi; - vci = (ACE_UINT16) mypvcaddr.sap_addr.vci; - - return 0; -#elif defined (SO_VCID) /* patch for atm version 0.59 */ - struct atm_vcid mypvcid; - int pvcidlen = sizeof (mypvcid); - if (ACE_OS::getsockopt (stream_.get_handle (), - SOL_ATM,SO_VCID, - reinterpret_cast (&mypvcid), - &pvcidlen) < 0) { - ACELIB_DEBUG (LM_DEBUG, - ACE_TEXT ("ACE_ATM_Stream::get_vpi_vci: getsockopt %d\n"), - errno); - return -1; - } - vpi = (ACE_UINT16) mypvcid.vpi; - vci = (ACE_UINT16) mypvcid.vci; - - return 0; -#else - ACELIB_DEBUG (LM_DEBUG, - ACE_TEXT ("ACE_ATM_Stream::get_vpi_vci: Not implemented in this ATM version. Update to >= 0.62\n Or patch 0.59")); - ACE_UNUSED_ARG (vci); - ACE_UNUSED_ARG (vpi); - - return -1; -#endif /* SO_ATMPVC || SO_VCID */ -#else - return -1; -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 || ACE_HAS_LINUX_ATM */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_ATM */ diff --git a/deps/acelite/ace/ATM_Stream.h b/deps/acelite/ace/ATM_Stream.h deleted file mode 100644 index 2e840a8dc..000000000 --- a/deps/acelite/ace/ATM_Stream.h +++ /dev/null @@ -1,103 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file ATM_Stream.h - * - * @author Joe Hoffert - */ -//============================================================================= - -#ifndef ACE_ATM_STREAM_H -#define ACE_ATM_STREAM_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_ATM) - -#include "ace/ATM_Addr.h" -#include "ace/ATM_Params.h" - -#if defined (ACE_WIN32) -#include "ace/SOCK_Stream.h" -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -typedef ACE_SOCK_Stream ATM_Stream; -ACE_END_VERSIONED_NAMESPACE_DECL -#else -#include "ace/TLI_Stream.h" -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -typedef ACE_TLI_Stream ATM_Stream; -ACE_END_VERSIONED_NAMESPACE_DECL -#endif - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_ATM_Stream - * - * @brief Defines the member functions for ACE_ATM_Stream abstraction. - */ -class ACE_Export ACE_ATM_Stream -{ -public: - /// Default constructor. - ACE_ATM_Stream (void); - - // = ATM-specific open and shutdown operations. - /// open the stream. - int open (ACE_ATM_Params params = ACE_ATM_Params()); - - /// Close down and release resources. - int close (void); - - /// Get the underlying handle. - ACE_HANDLE get_handle (void) const; - - /// Get the underlying stream. - ATM_Stream& get_stream (void); - - /// Get the name of the connected host. - char* get_peer_name (void) const; - - /// Get the VPI and VCI of the stream. - int get_vpi_vci (ACE_UINT16 &vpi, - ACE_UINT16 &vci) const; - - /// Recv an n byte buffer from the connected transport mechanism. - ssize_t recv (void *buf, - size_t n, - int *flags = 0) const; - - /// Send exactly n bytes to the connected transport mechanism. - ssize_t send_n (const void *buf, - size_t n, - int flags) const; - - // = Meta-type info - typedef ACE_ATM_Addr PEER_ADDR; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Typedef'd to the appropriate stream mechanism above. - ATM_Stream stream_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/ATM_Stream.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* ACE_HAS_ATM */ -#include /**/ "ace/post.h" -#endif /* ACE_ATM_STREAM_H */ diff --git a/deps/acelite/ace/ATM_Stream.inl b/deps/acelite/ace/ATM_Stream.inl deleted file mode 100644 index eda7ca9bc..000000000 --- a/deps/acelite/ace/ATM_Stream.inl +++ /dev/null @@ -1,130 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE void -ACE_ATM_Stream::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_ATM_Stream::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_INLINE -ACE_ATM_Stream::ACE_ATM_Stream (void) -{ - ACE_TRACE ("ACE_ATM_Stream::ACE_ATM_Stream"); -} - -ACE_INLINE -int -ACE_ATM_Stream::open (ACE_ATM_Params params) -{ - ACE_TRACE ("ACE_ATM_Stream::open"); -#if defined (ACE_HAS_FORE_ATM_XTI) - ACE_HANDLE handle = stream_.open (params.get_device(), - params.get_oflag(), - params.get_info()); - return (handle == ACE_INVALID_HANDLE ? -1 : 0); -#elif defined (ACE_HAS_FORE_ATM_WS2) - params.set_flags( ACE_FLAG_MULTIPOINT_C_ROOT | ACE_FLAG_MULTIPOINT_D_ROOT ); - - int retval = stream_.open (params.get_type(), - params.get_protocol_family(), - params.get_protocol(), - params.get_protocol_info(), - params.get_sock_group(), - params.get_flags(), - params.get_reuse_addr()); - if (retval == -1) - return -1; - - struct sockaddr_atm sock_addr; - - ACE_OS::memset(&sock_addr, 0, sizeof(struct sockaddr_atm)); - sock_addr.satm_family = AF_ATM; - sock_addr.satm_number.AddressType=ADDR_ANY; - sock_addr.satm_number.NumofDigits = ATM_ADDR_SIZE; - sock_addr.satm_blli.Layer2Protocol = SAP_FIELD_ABSENT; - sock_addr.satm_blli.Layer3Protocol = SAP_FIELD_ABSENT; - sock_addr.satm_bhli.HighLayerInfoType = SAP_FIELD_ABSENT; - if (ACE_OS::bind(get_handle(), - (struct sockaddr FAR *)&sock_addr, - sizeof(struct sockaddr_atm)) < 0) - { - ACE_OS::printf("Error binding local address: %d",WSAGetLastError()); - return -1; - } - - return 0; -#else - ACE_UNUSED_ARG(params); - return 0; -#endif /* ACE_HAS_FORE_ATM_XTI */ -} - -ACE_INLINE -int -ACE_ATM_Stream::close (void) -{ - ACE_TRACE ("ACE_ATM_Stream::close"); -#if defined (ACE_HAS_FORE_ATM_XTI) || defined (ACE_HAS_FORE_ATM_WS2) - return stream_.close (); -#else - return 0; -#endif /* ACE_HAS_FORE_ATM_XTI || ACE_HAS_FORE_ATM_WS2 */ -} - -ACE_INLINE -ATM_Stream& -ACE_ATM_Stream::get_stream (void) -{ - ACE_TRACE ("ACE_ATM_Stream::get_stream"); - return stream_; -} - -ACE_INLINE -ssize_t -ACE_ATM_Stream::recv (void *buf, - size_t n, - int *flags) const -{ - ACE_TRACE ("ACE_ATM_Stream::recv"); -#if defined (ACE_HAS_FORE_ATM_XTI) - return stream_.recv (buf, - n, - flags); -#elif defined (ACE_HAS_FORE_ATM_WS2) - return stream_.recv (buf, - n); -#else - ACE_UNUSED_ARG(buf); - ACE_UNUSED_ARG(n); - ACE_UNUSED_ARG(flags); - return 0; -#endif /* ACE_HAS_FORE_ATM_XTI */ -} - -ACE_INLINE -ssize_t -ACE_ATM_Stream::send_n (const void *buf, - size_t n, - int flags) const -{ - ACE_TRACE ("ACE_ATM_Stream::send_n"); -#if defined (ACE_HAS_FORE_ATM_XTI) - return stream_.send_n (buf, - n, - flags); -#elif defined (ACE_HAS_FORE_ATM_WS2) - return stream_.send_n (buf, - n, - flags); -#else - ACE_UNUSED_ARG(buf); - ACE_UNUSED_ARG(n); - ACE_UNUSED_ARG(flags); - return 0; -#endif /* ACE_HAS_FORE_ATM_XTI */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Abstract_Timer_Queue.cpp b/deps/acelite/ace/Abstract_Timer_Queue.cpp deleted file mode 100644 index 021c637fe..000000000 --- a/deps/acelite/ace/Abstract_Timer_Queue.cpp +++ /dev/null @@ -1,24 +0,0 @@ -#ifndef ACE_ABSTRACT_TIMER_QUEUE_CPP -#define ACE_ABSTRACT_TIMER_QUEUE_CPP -#include "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Abstract_Timer_Queue.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Even though the destructor is pure virtual you must provide an -// implementation. Most people know this, but sometimes we all -// forget, and we might be tempted to remove this code. -template -ACE_Abstract_Timer_Queue:: -~ACE_Abstract_Timer_Queue () -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_ABSTRACT_TIMER_QUEUE_CPP */ diff --git a/deps/acelite/ace/Abstract_Timer_Queue.h b/deps/acelite/ace/Abstract_Timer_Queue.h deleted file mode 100644 index 7dbbf7b4b..000000000 --- a/deps/acelite/ace/Abstract_Timer_Queue.h +++ /dev/null @@ -1,230 +0,0 @@ -#ifndef ACE_ABSTRACT_TIMER_QUEUE_H -#define ACE_ABSTRACT_TIMER_QUEUE_H - -#include /**/ "ace/pre.h" -/** - * @file Abstract_Timer_Queue.h - * - * @author Carlos O'Ryan - * - * Based on classes and files developed by Doug Schmidt, Darrell - * Brunsch, Irfan Pyarali and a cast of thousands. - */ - -#include "ace/Versioned_Namespace.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward declares -class ACE_Time_Value; -class ACE_Command_Base; -template class ACE_Timer_Queue_Iterator_T; -template class ACE_Timer_Node_T; - -/** - * @class ACE_Abstract_Timer_Queue - * - * @brief Base class for all timer queues of a single type. - * - * This is a base class for all the timer queues, regardless of - * locking strategy, upcall mechanism, internal implementation, etc. - * The class was motivated by bug 3706: - * http://bugzilla.dre.vanderbilt.edu/show_bug.cgi?id=3706 - * In short, the Reactor (and potentially other classes) want to refer - * to timer queues regardless of the implementation internals. - */ -template -class ACE_Abstract_Timer_Queue -{ -public: - /// Destructor - virtual ~ACE_Abstract_Timer_Queue (void) = 0; - - /// True if queue is empty, else false. - virtual bool is_empty (void) const = 0; - - /// Returns the time of the earlier node in the Timer_Queue. Must - /// be called on a non-empty queue. - virtual const ACE_Time_Value &earliest_time (void) const = 0; - - /** - * Schedule @a type that will expire at @a future_time, which is - * specified in absolute time. If it expires then @a act is passed - * in as the value to the . If @a interval is != to - * ACE_Time_Value::zero then it is used to reschedule the @a type - * automatically, using relative time to the current . - * This method returns a that uniquely identifies the the - * @a type entry in an internal list. This can be used to - * cancel the timer before it expires. The cancellation ensures - * that are unique up to values of greater than 2 - * billion timers. As long as timers don't stay around longer than - * this there should be no problems with accidentally deleting the - * wrong timer. Returns -1 on failure (which is guaranteed never to - * be a valid ). - */ - virtual long schedule (const TYPE &type, - const void *act, - const ACE_Time_Value &future_time, - const ACE_Time_Value &interval = ACE_Time_Value::zero) = 0; - - /** - * Run the for all timers whose values are <= @a current_time. - * This does not account for . Returns the number of - * timers canceled. - */ - virtual int expire (const ACE_Time_Value ¤t_time) = 0; - - /** - * Run the for all timers whose values are <= - * . Also accounts for . - * - * Depending on the resolution of the underlying OS the system calls - * like select()/poll() might return at time different than that is - * specified in the timeout. Suppose the OS guarantees a resolution of t ms. - * The timeline will look like - * - * A B - * | | - * V V - * |-------------|-------------|-------------|-------------| - * t t t t t - * - * - * If you specify a timeout value of A, then the timeout will not occur - * at A but at the next interval of the timer, which is later than - * that is expected. Similarly, if your timeout value is equal to B, - * then the timeout will occur at interval after B. Now depending upon the - * resolution of your timeouts and the accuracy of the timeouts - * needed for your application, you should set the value of - * . In the above case, if you want the timeout A to fire - * no later than A, then you should specify your to be - * A % t. - * - * The timeout value should be specified via the macro ACE_TIMER_SKEW - * in your config.h file. The default value is zero. - * - * Things get interesting if the t before the timeout value B is zero - * i.e your timeout is less than the interval. In that case, you are - * almost sure of not getting the desired timeout behaviour. Maybe you - * should look for a better OS :-) - * - * Returns the number of timers canceled. - */ - virtual int expire (void) = 0; - - /** - * A couple of classes using Timer_Queues need to dispatch a single - * event at a time. But before they dispatch the event they need to - * release a lock, signal other threads, etc. - * - * This member function should be used in that case. The additional - * operations to be called just before dispatching the event, and - * only if an event will be dispatched, are encapsulated in the - * ACE_Command_Base object. - */ - virtual int expire_single(ACE_Command_Base & pre_dispatch_command) = 0; - - /** - * Resets the interval of the timer represented by @a timer_id to - * @a interval, which is specified in relative time to the current - * . If @a interval is equal to - * ACE_Time_Value::zero, the timer will become a non-rescheduling - * timer. Returns 0 if successful, -1 if not. - */ - virtual int reset_interval (long timer_id, - const ACE_Time_Value &interval) = 0; - - /** - * Cancel all timer associated with @a type. If - * @a dont_call_handle_close is 0 then the will be invoked, - * which typically invokes the hook. Returns number - * of timers cancelled. - */ - virtual int cancel (const TYPE &type, - int dont_call_handle_close = 1) = 0; - - /** - * Cancel the single timer that matches the @a timer_id value (which - * was returned from the method). If act is non-NULL - * then it will be set to point to the ``magic cookie'' argument - * passed in when the timer was registered. This makes it possible - * to free up the memory and avoid memory leaks. If - * @a dont_call_handle_close is 0 then the will be invoked, - * which typically calls the hook. Returns 1 if - * cancellation succeeded and 0 if the @a timer_id wasn't found. - */ - virtual int cancel (long timer_id, - const void **act = 0, - int dont_call_handle_close = 1) = 0; - - /** - * Close timer queue. Cancels all timers. - */ - virtual int close (void) = 0; - - /** - * Returns the current time of day. This method allows different - * implementations of the timer queue to use special high resolution - * timers. - */ - virtual ACE_Time_Value gettimeofday (void) = 0; - - /** - * Allows applications to control how the timer queue gets the time - * of day. - * @deprecated Use TIME_POLICY support instead. See Timer_Queue_T.h - */ - virtual void gettimeofday (ACE_Time_Value (*gettimeofday)(void)) = 0; - - /// Determine the next event to timeout. Returns @a max if there are - /// no pending timers or if all pending timers are longer than max. - /// This method acquires a lock internally since it modifies internal state. - virtual ACE_Time_Value *calculate_timeout (ACE_Time_Value *max) = 0; - - /** - * Determine the next event to timeout. Returns @a max if there are - * no pending timers or if all pending timers are longer than max. - * @a the_timeout should be a pointer to storage for the timeout value, - * and this value is also returned. This method does not acquire a - * lock internally since it doesn't modify internal state. If you - * need to call this method when the queue is being modified - * concurrently, however, you should make sure to acquire the - * externally before making the call. - */ - virtual ACE_Time_Value *calculate_timeout (ACE_Time_Value *max, - ACE_Time_Value *the_timeout) = 0; - - /** - * Return the current time, using the right time policy and any - * timer skew defined in derived classes. - */ - virtual ACE_Time_Value current_time() = 0; - - /// Type of Iterator. - typedef ACE_Timer_Queue_Iterator_T ITERATOR; - - /// Returns a pointer to this ACE_Timer_Queue's iterator. - virtual ITERATOR & iter (void) = 0; - - /// Removes the earliest node from the queue and returns it - virtual ACE_Timer_Node_T *remove_first (void) = 0; - - /// Reads the earliest node from the queue and returns it. - virtual ACE_Timer_Node_T *get_first (void) = 0; - - /// Dump the state of a object. - virtual void dump (void) const = 0; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Abstract_Timer_Queue.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Abstract_Timer_Queue.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_ABSTRACT_TIMER_QUEUE_H */ diff --git a/deps/acelite/ace/Acceptor.cpp b/deps/acelite/ace/Acceptor.cpp deleted file mode 100644 index 6b0f8fdc2..000000000 --- a/deps/acelite/ace/Acceptor.cpp +++ /dev/null @@ -1,1254 +0,0 @@ -#ifndef ACE_ACCEPTOR_CPP -#define ACE_ACCEPTOR_CPP - -#include "ace/ACE.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Acceptor.h" -#include "ace/Svc_Handler.h" -#include "ace/WFMO_Reactor.h" -#include "ace/OS_NS_stdio.h" -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tca(ACE_Acceptor) - -template void -ACE_Acceptor::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Acceptor::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->peer_acceptor_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Acceptor::operator PEER_ACCEPTOR & () const -{ - ACE_TRACE ("ACE_Acceptor::operator PEER_ACCEPTOR &"); - return (PEER_ACCEPTOR &) this->peer_acceptor_; -} - -template PEER_ACCEPTOR & -ACE_Acceptor::acceptor (void) const -{ - ACE_TRACE ("ACE_Acceptor::acceptor"); - return const_cast (this->peer_acceptor_); -} - -// Returns ACE_HANDLE of the underlying Acceptor_Strategy. - -template ACE_HANDLE -ACE_Acceptor::get_handle (void) const -{ - ACE_TRACE ("ACE_Acceptor::get_handle"); - return this->peer_acceptor_.get_handle (); -} - -// Initialize the appropriate strategies for creation, passive -// connection acceptance, and concurrency, and then register -// with the Reactor and listen for connection requests at the -// designated . - -template int -ACE_Acceptor::open - (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, - ACE_Reactor *reactor, - int flags, - int use_select, - int reuse_addr) -{ - ACE_TRACE ("ACE_Acceptor::open"); - this->flags_ = flags; - this->use_select_ = use_select; - this->reuse_addr_ = reuse_addr; - this->peer_acceptor_addr_ = local_addr; - - // Must supply a valid Reactor to Acceptor::open()... - - if (reactor == 0) - { - errno = EINVAL; - return -1; - } - - // Open the underlying PEER_ACCEPTOR. - if (this->peer_acceptor_.open (local_addr, reuse_addr) == -1) - return -1; - - // Set the peer acceptor's handle into non-blocking mode. This is a - // safe-guard against the race condition that can otherwise occur - // between the time when indicates that a passive-mode - // socket handle is "ready" and when we call . During this - // interval, the client can shutdown the connection, in which case, - // the call can hang! - if (this->accept_strategy_->acceptor ().enable (ACE_NONBLOCK) != 0) - return -1; - - // Initialize the concurrency strategy. - - if (con_s == 0) - { - ACE_NEW_RETURN (con_s, - CONCURRENCY_STRATEGY, - -1); - this->delete_concurrency_strategy_ = true; - } - this->concurrency_strategy_ = con_s; - - // Initialize the scheduling strategy. - - if (sch_s == 0) - { - ACE_NEW_RETURN (sch_s, - SCHEDULING_STRATEGY, - -1); - this->delete_scheduling_strategy_ = true; - } - this->scheduling_strategy_ = sch_s; - - this->use_select_ = use_select; - - return this->reactor ()->register_handler - (this, - ACE_Event_Handler::ACCEPT_MASK); -} - -// Simple constructor. - -template -ACE_Strategy_Acceptor::ACE_Strategy_Acceptor - (const ACE_TCHAR service_name[], - const ACE_TCHAR service_description[], - int use_select, - int reuse_addr) - : creation_strategy_ (0), - delete_creation_strategy_ (false), - accept_strategy_ (0), - delete_accept_strategy_ (false), - concurrency_strategy_ (0), - delete_concurrency_strategy_ (false), - scheduling_strategy_ (0), - delete_scheduling_strategy_ (false), - service_name_ (0), - service_description_ (0) -{ - ACE_TRACE ("ACE_Strategy_Acceptor::ACE_Strategy_Acceptor"); - - if (service_name != 0) - ACE_ALLOCATOR (this->service_name_, - ACE_OS::strdup (service_name)); - if (service_description != 0) - ACE_ALLOCATOR (this->service_description_, - ACE_OS::strdup (service_description)); - this->use_select_ = use_select; - this->reuse_addr_ = reuse_addr; -} - -template -ACE_Strategy_Acceptor::ACE_Strategy_Acceptor - (const typename PEER_ACCEPTOR::PEER_ADDR &addr, - ACE_Reactor *reactor, - ACE_Creation_Strategy *cre_s, - ACE_Accept_Strategy *acc_s, - ACE_Concurrency_Strategy *con_s, - ACE_Scheduling_Strategy *sch_s, - const ACE_TCHAR service_name[], - const ACE_TCHAR service_description[], - int use_select, - int reuse_addr) - : creation_strategy_ (0), - delete_creation_strategy_ (false), - accept_strategy_ (0), - delete_accept_strategy_ (false), - concurrency_strategy_ (0), - delete_concurrency_strategy_ (false), - scheduling_strategy_ (0), - delete_scheduling_strategy_ (false), - service_name_ (0), - service_description_ (0) -{ - ACE_TRACE ("ACE_Strategy_Acceptor::ACE_Strategy_Acceptor"); - - if (this->open (addr, - reactor, - cre_s, - acc_s, - con_s, - sch_s, - service_name, - service_description, - use_select, - reuse_addr) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Strategy_Acceptor::ACE_Strategy_Acceptor"))); -} - -// Perform termination activities when is removed from the -// . - -template int -ACE_Strategy_Acceptor::handle_close (ACE_HANDLE, - ACE_Reactor_Mask) -{ - ACE_TRACE ("ACE_Strategy_Acceptor::handle_close"); - // Guard against multiple closes. - if (this->reactor () != 0) - { - ACE_HANDLE handle = this->get_handle (); - - if (this->delete_creation_strategy_) - delete this->creation_strategy_; - this->delete_creation_strategy_ = false; - this->creation_strategy_ = 0; - - if (this->delete_accept_strategy_) - delete this->accept_strategy_; - this->delete_accept_strategy_ = false; - this->accept_strategy_ = 0; - - if (this->delete_concurrency_strategy_) - delete this->concurrency_strategy_; - this->delete_concurrency_strategy_ = false; - this->concurrency_strategy_ = 0; - - if (this->delete_scheduling_strategy_) - delete this->scheduling_strategy_; - this->delete_scheduling_strategy_ = false; - this->scheduling_strategy_ = 0; - - // We must use the obtained *before* we deleted the - // accept_strategy_... - - this->reactor ()->remove_handler - (handle, - ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL); - - // Set the Reactor to 0 so that we don't try to close down - // again. - this->reactor (0); - } - return 0; -} - -// Bridge method for creating a . The strategy for -// creating a are configured into the Acceptor via it's -// . The default is to create a new -// . However, subclasses can override this strategy to -// perform creation in any way that they like (such as -// creating subclass instances of , using a singleton, -// dynamically linking the handler, etc.). - -template int -ACE_Strategy_Acceptor::make_svc_handler (SVC_HANDLER *&sh) -{ - ACE_TRACE ("ACE_Strategy_Acceptor::make_svc_handler"); - return this->creation_strategy_->make_svc_handler (sh); -} - -// Bridge method for accepting the new connection into the -// . The default behavior delegates to the -// in the Acceptor_Strategy. - -template int -ACE_Strategy_Acceptor::accept_svc_handler - (SVC_HANDLER *svc_handler) -{ - ACE_TRACE ("ACE_Strategy_Acceptor::accept_svc_handler"); - return this->accept_strategy_->accept_svc_handler (svc_handler); -} - -// Bridge method for activating a with the appropriate -// concurrency strategy. The default behavior of this method is to -// activate the SVC_HANDLER by calling its open() method (which allows -// the SVC_HANDLER to define its own concurrency strategy). However, -// subclasses can override this strategy to do more sophisticated -// concurrency activations (such as creating the SVC_HANDLER as an -// "active object" via multi-threading or multi-processing). - -template int -ACE_Strategy_Acceptor::activate_svc_handler - (SVC_HANDLER *svc_handler) -{ - ACE_TRACE ("ACE_Strategy_Acceptor::activate_svc_handler"); - return this->concurrency_strategy_->activate_svc_handler - (svc_handler, - (void *) this); -} - -template -ACE_Strategy_Acceptor::~ACE_Strategy_Acceptor (void) -{ - ACE_TRACE ("ACE_Strategy_Acceptor::~ACE_Strategy_Acceptor"); - ACE_OS::free ((void *) this->service_name_); - ACE_OS::free ((void *) this->service_description_); - this->handle_close (); -} - -// Signal the server to shutdown gracefully. - -template int -ACE_Strategy_Acceptor::handle_signal (int, siginfo_t *, ucontext_t *) -{ - ACE_Reactor::instance()->end_reactor_event_loop (); - return 0; -} - -template int -ACE_Strategy_Acceptor::info (ACE_TCHAR **strp, - size_t length) const -{ - ACE_TRACE ("ACE_Strategy_Acceptor::info"); - - ACE_TCHAR buf[BUFSIZ]; - ACE_TCHAR service_addr_str[BUFSIZ]; - typename PEER_ACCEPTOR::PEER_ADDR addr; - - if (this->acceptor ().get_local_addr (addr) == -1) - return -1; - else if (addr.addr_to_string (service_addr_str, - sizeof service_addr_str) == -1) - return -1; - - // @@ Should add the protocol in... - ACE_OS::snprintf (buf, BUFSIZ, - ACE_TEXT ("%s\t %s #%s\n"), - this->service_name_ == 0 - ? ACE_TEXT ("") - : this->service_name_, - service_addr_str, - this->service_description_ == 0 - ? ACE_TEXT ("") - : this->service_description_); - - if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0) - return -1; - else - ACE_OS::strsncpy (*strp, buf, length); - return static_cast (ACE_OS::strlen (buf)); -} - -template int -ACE_Strategy_Acceptor::fini (void) -{ - ACE_TRACE ("ACE_Strategy_Acceptor::fini"); - return this->ACE_Strategy_Acceptor::handle_close (); -} - -ACE_ALLOC_HOOK_DEFINE_Tca(ACE_Oneshot_Acceptor) - -template void -ACE_Oneshot_Acceptor::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Oneshot_Acceptor::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nsvc_handler_ = %x"), this->svc_handler_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nrestart_ = %d"), this->restart_)); - this->peer_acceptor_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_concurrency_strategy_ = %d"), - delete_concurrency_strategy_)); - this->concurrency_strategy_->dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -template int -ACE_Oneshot_Acceptor::open - (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, - ACE_Reactor *reactor, - ACE_Concurrency_Strategy *con_s) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::open"); - this->reactor (reactor); - - // Initialize the concurrency strategy. - - if (con_s == 0) - { - ACE_NEW_RETURN (con_s, - ACE_Concurrency_Strategy, - -1); - this->delete_concurrency_strategy_ = true; - } - this->concurrency_strategy_ = con_s; - - // Reuse the addr, even if it is already in use...! - return this->peer_acceptor_.open (local_addr, 1); -} - -template -ACE_Oneshot_Acceptor::ACE_Oneshot_Acceptor (void) - : svc_handler_ (0), - restart_ (false), - concurrency_strategy_ (0), - delete_concurrency_strategy_ (false) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::ACE_Oneshot_Acceptor"); - this->reactor (0); -} - -template -ACE_Oneshot_Acceptor::ACE_Oneshot_Acceptor - (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, - ACE_Reactor *reactor, - ACE_Concurrency_Strategy *cs) - : svc_handler_ (0), - restart_ (false), - concurrency_strategy_ (0), - delete_concurrency_strategy_ (false) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::ACE_Oneshot_Acceptor"); - if (this->open (local_addr, reactor, cs) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Oneshot_Acceptor::ACE_Oneshot_Acceptor"))); -} - -template -ACE_Oneshot_Acceptor::~ACE_Oneshot_Acceptor (void) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::~ACE_Oneshot_Acceptor"); - this->handle_close (); -} - -template int -ACE_Oneshot_Acceptor::close (void) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::close"); - return this->handle_close (); -} - -template int -ACE_Oneshot_Acceptor::handle_close (ACE_HANDLE, - ACE_Reactor_Mask) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::handle_close"); - - // Guard against multiple closes. - if (this->delete_concurrency_strategy_) - { - delete this->concurrency_strategy_; - this->delete_concurrency_strategy_ = false; - this->concurrency_strategy_ = 0; - } - // Note that if we aren't actually registered with the - // ACE_Reactor then it's ok for this call to fail... - - if (this->reactor ()) - this->reactor ()->remove_handler - (this, - ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL); - - if (this->peer_acceptor_.close () == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("close\n"))); - return 0; -} - -template int -ACE_Oneshot_Acceptor::handle_timeout - (const ACE_Time_Value &tv, - const void *arg) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::handle_timeout"); - errno = ETIME; - - if (this->svc_handler_->handle_timeout (tv, arg) == -1) - this->svc_handler_->handle_close (this->svc_handler_->get_handle (), - ACE_Event_Handler::TIMER_MASK); - - // Since we aren't necessarily registered with the Reactor, don't - // bother to check the return value here... - if (this->reactor ()) - this->reactor ()->remove_handler (this, - ACE_Event_Handler::ACCEPT_MASK); - return 0; -} - -template int -ACE_Oneshot_Acceptor::cancel (void) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::cancel"); - return this->reactor () && this->reactor ()->cancel_timer (this); -} - -template int -ACE_Oneshot_Acceptor::register_handler - (SVC_HANDLER *svc_handler, - const ACE_Synch_Options &synch_options, - bool restart) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::register_handler"); - // Can't do this if we don't have a Reactor. - if (this->reactor () == 0) - { - errno = EINVAL; - return -1; - } - else - { - this->svc_handler_ = svc_handler; - this->restart_ = restart; - ACE_Time_Value *tv = (ACE_Time_Value *) synch_options.time_value (); - - if (tv != 0 - && this->reactor ()->schedule_timer (this, - synch_options.arg (), - *tv) == -1) - return -1; - else - return this->reactor ()->register_handler - (this, - ACE_Event_Handler::ACCEPT_MASK); - } -} - -// Bridge method for activating a with the appropriate -// concurrency strategy. The default behavior of this method is to -// activate the SVC_HANDLER by calling its open() method (which allows -// the SVC_HANDLER to define its own concurrency strategy). However, -// subclasses can override this strategy to do more sophisticated -// concurrency activations (such as creating the SVC_HANDLER as an -// "active object" via multi-threading or multi-processing). - -template int -ACE_Oneshot_Acceptor::activate_svc_handler - (SVC_HANDLER *svc_handler) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::activate_svc_handler"); - return this->concurrency_strategy_->activate_svc_handler - (svc_handler, - (void *) this); -} - -// Factors out the code shared between the and -// methods. - -template int -ACE_Oneshot_Acceptor::shared_accept - (SVC_HANDLER *svc_handler, - typename PEER_ACCEPTOR::PEER_ADDR *remote_addr, - ACE_Time_Value *timeout, - bool restart, - bool reset_new_handle) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::shared_accept"); - if (svc_handler == 0) - return -1; - - // Accept connection into the Svc_Handler. - else if (this->peer_acceptor_.accept (svc_handler->peer (), // stream - remote_addr, // remote address - timeout, // timeout - restart, // restart - reset_new_handle // reset new handle - ) == -1) - { - // Check whether we just timed out or whether we failed... - if (!(errno == EWOULDBLOCK || errno == ETIME)) - // Close down handler to avoid memory leaks. - svc_handler->close (CLOSE_DURING_NEW_CONNECTION); - return -1; - } - // Activate the using the designated concurrency - // strategy (note that this method becomes responsible for handling - // errors and freeing up the memory if things go awry...) - else - return this->activate_svc_handler (svc_handler); -} - -// Make a SVC_HANDLER, accept the connection into the SVC_HANDLER, and -// then activate the SVC_HANDLER. Note that SVC_HANDLER::open() -// decides what type of concurrency strategy to use. - -template int -ACE_Oneshot_Acceptor::accept - (SVC_HANDLER *svc_handler, - typename PEER_ACCEPTOR::PEER_ADDR *remote_addr, - const ACE_Synch_Options &synch_options, - bool restart, - bool reset_new_handle) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::accept"); - // Note that if timeout == ACE_Time_Value (x, y) where (x > 0 || y > - // 0) then this->connector_.connect() will block synchronously. If - // is set then we don't want this to happen (since we - // want the ACE_Reactor to do the timeout asynchronously). - // Therefore, we'll force this->connector_ to use ACE_Time_Value (0, - // 0) in this case... - - ACE_Time_Value *timeout; - int use_reactor = synch_options[ACE_Synch_Options::USE_REACTOR]; - - if (use_reactor) - timeout = (ACE_Time_Value *) &ACE_Time_Value::zero; - else - timeout = (ACE_Time_Value *) synch_options.time_value (); - - if (this->shared_accept (svc_handler, // stream - remote_addr, // remote address - timeout, // timeout - restart, // restart - reset_new_handle // reset new handler - ) == -1) - { - if (use_reactor && errno == EWOULDBLOCK) - // We couldn't accept right away, so let's wait in the - // . - this->register_handler (svc_handler, - synch_options, - restart); - return -1; - } - return 0; -} - -// Accepts one pending connection from a client (since we're the -// "oneshot" Acceptor). - -template int -ACE_Oneshot_Acceptor::handle_input (ACE_HANDLE) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::handle_input"); - int result = 0; - - // Cancel any timer that might be pending. - this->cancel (); - - // Try to find out if the implementation of the reactor that we are - // using requires us to reset the event association for the newly - // created handle. This is because the newly created handle will - // inherit the properties of the listen handle, including its event - // associations. - ACE_Reactor *reactor = this->reactor (); - bool reset_new_handle = false; - - // There is a use-case whereby this object will be gone upon return - // from shared_accept - if the Svc_Handler deletes this Oneshot_Acceptor - // during the shared_accept/activation steps. So, do whatever we need - // to do with this object before calling shared_accept. - if (reactor) - { - reset_new_handle = reactor->uses_event_associations (); - reactor->remove_handler - (this, - ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL); - } - - if (this->shared_accept (this->svc_handler_, // stream - 0, // remote address - 0, // timeout - this->restart_, // restart - reset_new_handle // reset new handle - ) == -1) - result = -1; - - return result; -} - -// Hook called by the explicit dynamic linking facility. - -template int -ACE_Oneshot_Acceptor::init (int, ACE_TCHAR *[]) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::init"); - return -1; -} - -template int -ACE_Oneshot_Acceptor::fini (void) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::fini"); - return this->handle_close (); -} - -template int -ACE_Oneshot_Acceptor::info (ACE_TCHAR **strp, - size_t length) const -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::info"); - ACE_TCHAR buf[BUFSIZ]; - ACE_TCHAR addr_str[BUFSIZ]; - typename PEER_ACCEPTOR::PEER_ADDR addr; - - if (this->peer_acceptor_.get_local_addr (addr) == -1) - return -1; - else if (addr.addr_to_string (addr_str, sizeof addr_str) == -1) - return -1; - - ACE_OS::snprintf (buf, BUFSIZ, - ACE_TEXT ("%s\t %s %s"), - ACE_TEXT ("ACE_Oneshot_Acceptor"), - addr_str, - ACE_TEXT ("#oneshot acceptor factory\n")); - - if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0) - return -1; - else - ACE_OS::strsncpy (*strp, buf, length); - return static_cast (ACE_OS::strlen (buf)); -} - -template int -ACE_Oneshot_Acceptor::suspend (void) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::suspend"); - return this->reactor () && this->reactor ()->suspend_handler (this); -} - -template int -ACE_Oneshot_Acceptor::resume (void) -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::resume"); - return this->reactor () && this->reactor ()->resume_handler (this); -} - -// Returns ACE_HANDLE of the underlying peer_acceptor. - -template ACE_HANDLE -ACE_Oneshot_Acceptor::get_handle (void) const -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::get_handle"); - return this->peer_acceptor_.get_handle (); -} - -template PEER_ACCEPTOR & -ACE_Oneshot_Acceptor::acceptor (void) const -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::acceptor"); - return (PEER_ACCEPTOR &) this->peer_acceptor_; -} - -template -ACE_Oneshot_Acceptor::operator PEER_ACCEPTOR & () const -{ - ACE_TRACE ("ACE_Oneshot_Acceptor::operator PEER_ACCEPTOR &"); - return (PEER_ACCEPTOR &) this->peer_acceptor_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_ACCEPTOR_CPP */ diff --git a/deps/acelite/ace/Acceptor.h b/deps/acelite/ace/Acceptor.h deleted file mode 100644 index da7834cc9..000000000 --- a/deps/acelite/ace/Acceptor.h +++ /dev/null @@ -1,698 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Acceptor.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_ACCEPTOR_H -#define ACE_ACCEPTOR_H - -#include /**/ "ace/pre.h" - -#include "ace/Service_Object.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Strategies_T.h" -#include "ace/Synch_Options.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Acceptor - * - * @brief Abstract factory for creating a service handler - * (SVC_HANDLER), accepting into the SVC_HANDLER, and - * activating the SVC_HANDLER. - * - * Implements the basic strategy for passively establishing - * connections with clients. An ACE_Acceptor inherits from - * ACE_Service_Object, which in turn inherits from ACE_Event_Handler. - * This enables the ACE_Reactor to dispatch the ACE_Acceptor's - * handle_input method when connection events occur. The handle_input - * method performs the ACE_Acceptor's default creation, connection - * establishment, and service activation strategies. These strategies - * can be overridden by subclasses individually or as a group. - * - * An ACE_Acceptor is parameterized by concrete types that conform to - * the interfaces of SVC_HANDLER and PEER_ACCEPTOR described below. - * - * @tparam SVC_HANDLER The name of the concrete type that performs the - * application-specific service. The SVC_HANDLER typically - * inherits from ACE_Svc_Handler. @see Svc_Handler.h. - * - * @tparam PEER_ACCEPTOR The name of the class that implements the - * PEER_ACCEPTOR endpoint (e.g., ACE_SOCK_Acceptor) to - * passively establish connections. A PEER_ACCEPTOR - * implementation must provide a PEER_STREAM and PEER_ADDR - * trait to identify the type of stream (e.g., - * ACE_SOCK_Stream) and type of address (e.g., ACE_INET_Addr) - * used by the endpoint. - */ -template -class ACE_Acceptor : public ACE_Service_Object -{ -public: - // Useful STL-style traits. - typedef typename PEER_ACCEPTOR::PEER_ADDR addr_type; - typedef PEER_ACCEPTOR acceptor_type; - typedef SVC_HANDLER handler_type; - typedef typename SVC_HANDLER::stream_type stream_type; - - /// "Do-nothing" constructor. - ACE_Acceptor (ACE_Reactor * = 0, - int use_select = ACE_DEFAULT_ACCEPTOR_USE_SELECT); - - /** - * Open the contained @c PEER_ACCEPTOR object to begin listening, and - * register with the specified reactor for accept events. An - * acceptor can only listen to one port at a time, so make sure to - * @c close() the acceptor before calling @c open() again. - * - * The @c PEER_ACCEPTOR handle is put into non-blocking mode as a - * safeguard against the race condition that can otherwise occur - * between the time when the passive-mode socket handle is "ready" - * and when the actual @c accept() call is made. During this - * interval, the client can shutdown the connection, in which case, - * the @c accept() call can hang. - * - * @param local_addr The address to listen at. - * @param reactor Pointer to the ACE_Reactor instance to register - * this object with. The default is the singleton. - * @param flags Flags to control what mode an accepted socket - * will be put into after it is accepted. The only - * legal value for this argument is @c ACE_NONBLOCK, - * which enables non-blocking mode on the accepted - * peer stream object in @c SVC_HANDLER. The default - * is 0. - * @param use_select Affects behavior when called back by the reactor - * when a connection can be accepted. If non-zero, - * this object will accept all pending connections, - * instead of just the one that triggered the reactor - * callback. Uses ACE_OS::select() internally to - * detect any remaining acceptable connections. - * The default is 1. - * @param reuse_addr Passed to the @c PEER_ACCEPTOR::open() method with - * @p local_addr. Generally used to request that the - * OS allow reuse of the listen port. The default is 1. - */ - ACE_Acceptor (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, - ACE_Reactor *reactor = ACE_Reactor::instance (), - int flags = 0, - int use_select = ACE_DEFAULT_ACCEPTOR_USE_SELECT, - int reuse_addr = 1); - - /** - * Open the contained @c PEER_ACCEPTOR object to begin listening, and - * register with the specified reactor for accept events. An - * acceptor can only listen to one port at a time, so make sure to - * @c close() the acceptor before calling @c open() again. - * - * The @c PEER_ACCEPTOR handle is put into non-blocking mode as a - * safeguard against the race condition that can otherwise occur - * between the time when the passive-mode socket handle is "ready" - * and when the actual @c accept() call is made. During this - * interval, the client can shutdown the connection, in which case, - * the @c accept() call can hang. - * - * @param local_addr The address to listen at. - * @param reactor Pointer to the ACE_Reactor instance to register - * this object with. The default is the singleton. - * @param flags Flags to control what mode an accepted socket - * will be put into after it is accepted. The only - * legal value for this argument is @c ACE_NONBLOCK, - * which enables non-blocking mode on the accepted - * peer stream object in @c SVC_HANDLER. The default - * is 0. - * @param use_select Affects behavior when called back by the reactor - * when a connection can be accepted. If non-zero, - * this object will accept all pending connections, - * instead of just the one that triggered the reactor - * callback. Uses ACE_OS::select() internally to - * detect any remaining acceptable connections. - * The default is 1. - * @param reuse_addr Passed to the @c PEER_ACCEPTOR::open() method with - * @p local_addr. Generally used to request that the - * OS allow reuse of the listen port. The default is 1. - * - * @retval 0 Success - * @retval -1 Failure, @c errno contains an error code. - */ - virtual int open (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, - ACE_Reactor *reactor = ACE_Reactor::instance (), - int flags = 0, - int use_select = ACE_DEFAULT_ACCEPTOR_USE_SELECT, - int reuse_addr = 1); - - /// Close down the Acceptor's resources. - virtual ~ACE_Acceptor (void); - - /// Return the underlying PEER_ACCEPTOR object. - virtual operator PEER_ACCEPTOR &() const; - - /// Return the underlying PEER_ACCEPTOR object. - virtual PEER_ACCEPTOR &acceptor (void) const; - - /// Returns the listening acceptor's {ACE_HANDLE}. - virtual ACE_HANDLE get_handle (void) const; - - /// Close down the Acceptor - virtual int close (void); - - /// In the event that an accept fails, this method will be called and - /// the return value will be returned from handle_input(). - virtual int handle_accept_error (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - // = The following three methods define the Acceptor's strategies - // for creating, accepting, and activating SVC_HANDLER's, - // respectively. - - /** - * Bridge method for creating a SVC_HANDLER. The default is to - * create a new {SVC_HANDLER} if {sh} == 0, else {sh} is unchanged. - * However, subclasses can override this policy to perform - * SVC_HANDLER creation in any way that they like (such as creating - * subclass instances of SVC_HANDLER, using a singleton, dynamically - * linking the handler, etc.). Returns -1 on failure, else 0. - */ - virtual int make_svc_handler (SVC_HANDLER *&sh); - - /** - * Bridge method for accepting the new connection into the - * @a svc_handler. The default behavior delegates to the - * PEER_ACCEPTOR::accept. - */ - virtual int accept_svc_handler (SVC_HANDLER *svc_handler); - - /** - * Bridge method for activating a @a svc_handler with the appropriate - * concurrency strategy. The default behavior of this method is to - * activate the SVC_HANDLER by calling its open() method (which - * allows the SVC_HANDLER to define its own concurrency strategy). - * However, subclasses can override this strategy to do more - * sophisticated concurrency activations (such as making the - * SVC_HANDLER as an "active object" via multi-threading or - * multi-processing). - */ - virtual int activate_svc_handler (SVC_HANDLER *svc_handler); - - // = Demultiplexing hooks. - /// Perform termination activities when {this} is removed from the - /// {reactor}. - virtual int handle_close (ACE_HANDLE = ACE_INVALID_HANDLE, - ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK); - - /// Accepts all pending connections from clients, and creates and - /// activates SVC_HANDLERs. - virtual int handle_input (ACE_HANDLE); - - // = Dynamic linking hooks. - /// Default version does no work and returns -1. Must be overloaded - /// by application developer to do anything meaningful. - virtual int init (int argc, ACE_TCHAR *argv[]); - - /// Calls {handle_close}. - virtual int fini (void); - - /// Default version returns address info in {buf}. - virtual int info (ACE_TCHAR **buf, size_t) const; - -public: - // = Service management hooks. - /// This method calls {Reactor::suspend}. - virtual int suspend (void); - - /// This method calls {Reactor::resume}. - virtual int resume (void); - -protected: - /// Concrete factory for accepting connections from clients... - PEER_ACCEPTOR peer_acceptor_; - - /// Needed to reopen the socket if {accept} fails. - typename PEER_ACCEPTOR::PEER_ADDR peer_acceptor_addr_; - - /** - * Flags that indicate how {SVC_HANDLER}'s should be initialized - * prior to being activated. Right now, the only flag that is - * processed is {ACE_NONBLOCK}, which enabled non-blocking I/O on - * the {SVC_HANDLER} when it is opened. - */ - int flags_; - - /// Flag that indicates whether it shall use {select} in the - /// {accept}-loop. - int use_select_; - - /// Needed to reopen the socket if {accept} fails. - int reuse_addr_; -}; - -/** - * @class ACE_Strategy_Acceptor - * - * @brief Abstract factory for creating a service handler - * (SVC_HANDLER), accepting into the SVC_HANDLER, and activating - * the SVC_HANDLER. - * - * Implements a flexible and extensible set of strategies for - * passively establishing connections with clients. There are - * three main strategies: (1) creating a SVC_HANDLER, (2) - * passively accepting a new connection from a client into the - * SVC_HANDLER, and (3) activating the SVC_HANDLER with a - * particular concurrency mechanism. - */ -template -class ACE_Strategy_Acceptor - : public ACE_Acceptor -{ -public: - // Useful STL-style traits. - typedef ACE_Creation_Strategy - creation_strategy_type; - typedef ACE_Accept_Strategy - accept_strategy_type; - typedef ACE_Concurrency_Strategy - concurrency_strategy_type; - typedef ACE_Scheduling_Strategy scheduling_strategy_type; - typedef ACE_Acceptor - base_type; - - // = Define some useful (old style) traits. - typedef ACE_Creation_Strategy CREATION_STRATEGY; - typedef ACE_Accept_Strategy ACCEPT_STRATEGY; - typedef ACE_Concurrency_Strategy CONCURRENCY_STRATEGY; - typedef ACE_Scheduling_Strategy SCHEDULING_STRATEGY; - - /// Default constructor. - ACE_Strategy_Acceptor (const ACE_TCHAR service_name[] = 0, - const ACE_TCHAR service_description[] = 0, - int use_select = ACE_DEFAULT_ACCEPTOR_USE_SELECT, - int reuse_addr = 1); - - /** - * Initialize the appropriate strategies for creation, passive - * connection acceptance, and concurrency, and then register {this} - * with the Reactor and listen for connection requests at the - * designated {local_addr}. - */ - ACE_Strategy_Acceptor (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, - ACE_Reactor * = ACE_Reactor::instance (), - ACE_Creation_Strategy * = 0, - ACE_Accept_Strategy * = 0, - ACE_Concurrency_Strategy * = 0, - ACE_Scheduling_Strategy * = 0, - const ACE_TCHAR service_name[] = 0, - const ACE_TCHAR service_description[] = 0, - int use_select = ACE_DEFAULT_ACCEPTOR_USE_SELECT, - int reuse_addr = 1); - - /** - * Open the contained @c PEER_ACCEPTOR object to begin listening, and - * register with the specified reactor for accept events. - * - * The @c PEER_ACCEPTOR handle is put into non-blocking mode as a - * safeguard against the race condition that can otherwise occur - * between the time when the passive-mode socket handle is "ready" - * and when the actual @c accept call is made. During this - * interval, the client can shutdown the connection, in which case, - * the {accept} call can hang. - * - * @param local_addr The address to listen at. - * @param reactor Pointer to the ACE_Reactor instance to register - * this object with. The default is the singleton. - * @param flags Flags to control what mode an accepted socket - * will be put into after it is accepted. The only - * legal value for this argument is @c ACE_NONBLOCK, - * which enables non-blocking mode on the accepted - * peer stream object in @c SVC_HANDLER. The default - * is 0. - * @param use_select Affects behavior when called back by the reactor - * when a connection can be accepted. If non-zero, - * this object will accept all pending connections, - * instead of just the one that triggered the reactor - * callback. Uses ACE_OS::select() internally to - * detect any remaining acceptable connections. - * The default is 1. - * @param reuse_addr Passed to the @c PEER_ACCEPTOR::open() method with - * @p local_addr. Generally used to request that the - * OS allow reuse of the listen port. The default is 1. - * - * @retval 0 Success - * @retval -1 Failure, @c errno contains an error code. - */ - virtual int open (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, - ACE_Reactor *reactor, - int flags = 0, - int use_select = ACE_DEFAULT_ACCEPTOR_USE_SELECT, - int reuse_addr = 1); - - /** - * Initialize the appropriate strategies for creation, passive - * connection acceptance, and concurrency, and then register {this} - * with the Reactor and listen for connection requests at the - * designated {local_addr}. - */ - virtual int open (const typename PEER_ACCEPTOR::PEER_ADDR &, - ACE_Reactor * = ACE_Reactor::instance (), - ACE_Creation_Strategy * = 0, - ACE_Accept_Strategy * =0, - ACE_Concurrency_Strategy * = 0, - ACE_Scheduling_Strategy * = 0, - const ACE_TCHAR *service_name = 0, - const ACE_TCHAR *service_description = 0, - int use_select = ACE_DEFAULT_ACCEPTOR_USE_SELECT, - int reuse_addr = 1); - - /// Close down the Strategy_Acceptor's resources. - virtual ~ACE_Strategy_Acceptor (void); - - /// Return the underlying PEER_ACCEPTOR object. - virtual operator PEER_ACCEPTOR &() const; - - /// Return the underlying PEER_ACCEPTOR object. - virtual PEER_ACCEPTOR &acceptor (void) const; - - /// Returns the listening acceptor's {ACE_HANDLE}. - virtual ACE_HANDLE get_handle (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - // = Service management hooks. - - /// This method delegates to the {Scheduling_Strategy}'s {suspend} - /// method. - virtual int suspend (void); - - /// This method delegates to the {Scheduling_Strategy}'s {resume} - /// method. - virtual int resume (void); - -protected: - - /// Calls {handle_close} when dynamically unlinked. - virtual int fini (void); - - /// Default version returns address info in {buf}. - virtual int info (ACE_TCHAR **buf, size_t) const; - - // = The following three methods define the {Acceptor}'s strategies - // for creating, accepting, and activating {SVC_HANDLER}'s, - // respectively. - - /** - * Bridge method for creating a {SVC_HANDLER}. The strategy for - * creating a {SVC_HANDLER} are configured into the Acceptor via - * it's {creation_strategy_}. The default is to create a new - * {SVC_HANDLER} if {sh} == 0, else {sh} is unchanged. However, - * subclasses can override this policy to perform {SVC_HANDLER} - * creation in any way that they like (such as creating subclass - * instances of {SVC_HANDLER}, using a singleton, dynamically - * linking the handler, etc.). Returns -1 on failure, else 0. - */ - virtual int make_svc_handler (SVC_HANDLER *&); - - /** - * Bridge method for accepting the new connection into the - * {SVC_HANDLER}. The default behavior delegates to the - * {PEER_ACCEPTOR::accept} in the {Acceptor_Strategy}. - */ - virtual int accept_svc_handler (SVC_HANDLER *svc_handler); - - /** - * Bridge method for activating a {SVC_HANDLER} with the appropriate - * concurrency strategy. The default behavior of this method is to - * activate the {SVC_HANDLER} by calling its {open} method (which - * allows the {SVC_HANDLER} to define its own concurrency strategy). - * However, subclasses can override this strategy to do more - * sophisticated concurrency activations (such as creating the - * {SVC_HANDLER} as an "active object" via multi-threading or - * multi-processing). - */ - virtual int activate_svc_handler (SVC_HANDLER *svc_handler); - - // = Demultiplexing hooks. - /// Perform termination activities when {this} is removed from the - /// {Reactor}. - virtual int handle_close (ACE_HANDLE = ACE_INVALID_HANDLE, - ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK); - - /// Handle SIGINT. - virtual int handle_signal (int signum, siginfo_t *, ucontext_t *); - - // = These data members are "logically private" but are put in the - // protected part in case subclasses want to access them. - - // = Strategy objects. - - /// Creation strategy for an Acceptor. - CREATION_STRATEGY *creation_strategy_; - - /// true if {Acceptor} created the creation strategy and thus should - /// delete it, else false. - bool delete_creation_strategy_; - - /// Accept strategy for an {Acceptor}. - ACCEPT_STRATEGY *accept_strategy_; - - /// true if {Acceptor} created the accept strategy and thus should delete - /// it, else false. - bool delete_accept_strategy_; - - /// Concurrency strategy for an {Acceptor}. - CONCURRENCY_STRATEGY *concurrency_strategy_; - - /// true if {Acceptor} created the concurrency strategy and thus should - /// delete it, else false. - bool delete_concurrency_strategy_; - - /// Scheduling strategy for an {Acceptor}. - SCHEDULING_STRATEGY *scheduling_strategy_; - - /// true if {Acceptor} created the scheduling strategy and thus should - /// delete it, else false. - bool delete_scheduling_strategy_; - - // = Service information objects. - - /// Name of the service. - ACE_TCHAR *service_name_; - - /// Description of the service. - ACE_TCHAR *service_description_; - - /// Address that the {Strategy_Acceptor} uses to listen for - /// connections. - typename PEER_ACCEPTOR::PEER_ADDR service_addr_; -}; - -/** - * @class ACE_Oneshot_Acceptor - * - * @brief Generic factory for passively connecting clients and creating - * exactly one service handler of the type SVC_HANDLER specified in the - * template. - * - * This class works similarly to the regular ACE_Acceptor, but - * with the following differences: - * -# ACE_Oneshot_Acceptor doesn't automatically register itself with the - * ACE_Reactor; the caller is expected to call the accept() method - * directly. Since a later call to accept() may require a reactor, - * the constructor and open() methods both accept an ACE_Reactor pointer - * which is saved in case it's needed in accept(). - * -# ACE_Oneshot_Acceptor doesn't need an ACE_Creation_Strategy (because - * the user supplies the SVC_HANDLER) or an ACE_Accept_Strategy (because - * this class only accepts one connection and then removes all traces of - * itself from the ACE_Reactor if it was registered for asynchronous - * accepts). - * - * The usage model for ACE_Oneshot_Acceptor is: - * - Instantiate an object and establish its local address to listen at. - * This can be accomplished using either the address-accepting constructor - * (but there's no error indication) or the default constructor followed - * by a call to open(). - * - Call the accept() method. This will attempt to accept a connection - * immediately. If there is no immediately available connection to accept, - * behavior is governed by the ACE_Synch_Options argument passed to open(). - */ -template -class ACE_Oneshot_Acceptor : public ACE_Service_Object -{ -public: - // Useful STL-style traits. - typedef typename PEER_ACCEPTOR::PEER_ADDR addr_type; - typedef PEER_ACCEPTOR acceptor_type; - typedef SVC_HANDLER handler_type; - typedef typename SVC_HANDLER::stream_type stream_type; - - /// Constructor. - ACE_Oneshot_Acceptor (void); - - /** - * Initialize the appropriate strategies for concurrency and then - * open the acceptor at the designated @a local_addr. Note - * that unlike ACE_Acceptor and ACE_Strategy_Acceptor, this - * method does NOT register this acceptor with the @a reactor at - * this point -- the @a reactor parameter is saved in case it's - * needed later. - */ - ACE_Oneshot_Acceptor (const typename PEER_ACCEPTOR::PEER_ADDR &local_addr, - ACE_Reactor *reactor = ACE_Reactor::instance (), - ACE_Concurrency_Strategy * = 0); - - /** - * Initialize the appropriate strategies for concurrency and then - * open the acceptor at the designated @a local_addr. Note - * that unlike ACE_Acceptor and ACE_Strategy_Acceptor, this - * method does NOT register this acceptor with the @a reactor at - * this point -- the @a reactor parameter is saved in case it's - * needed later. - */ - int open (const typename PEER_ACCEPTOR::PEER_ADDR &, - ACE_Reactor *reactor = ACE_Reactor::instance (), - ACE_Concurrency_Strategy * = 0); - - /// Close down the {Oneshot_Acceptor}. - virtual ~ACE_Oneshot_Acceptor (void); - - // = Explicit factory operation. - /// Create a {SVC_HANDLER}, accept the connection into the - /// {SVC_HANDLER}, and activate the {SVC_HANDLER}. - virtual int accept (SVC_HANDLER * = 0, - typename PEER_ACCEPTOR::PEER_ADDR *remote_addr = 0, - const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults, - bool restart = true, - bool reset_new_handle = false); - - /// Cancel a oneshot acceptor that was started asynchronously. - virtual int cancel (void); - - /// Return the underlying {PEER_ACCEPTOR} object. - virtual operator PEER_ACCEPTOR &() const; - - /// Return the underlying {PEER_ACCEPTOR} object. - virtual PEER_ACCEPTOR &acceptor (void) const; - - /// Close down the {Oneshot_Acceptor}. - virtual int close (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /** - * Bridge method for activating a {svc_handler} with the appropriate - * concurrency strategy. Default behavior is to activate the - * {SVC_HANDLER} as a "passive object." However, subclasses can - * override this strategy to do more sophisticated concurrency - * activations (such as creating the {SVC_HANDLER} as an "active - * object" via multi-threading or multi-processing). - */ - virtual int activate_svc_handler (SVC_HANDLER *svc_handler); - - /// Factors out the code shared between the {accept} and - /// {handle_input} methods. - int shared_accept (SVC_HANDLER *svc_handler, - typename PEER_ACCEPTOR::PEER_ADDR *remote_addr, - ACE_Time_Value *timeout, - bool restart, - bool reset_new_handle); - - // = Demultiplexing hooks. - /// Returns the listening acceptor's {ACE_HANDLE}. - virtual ACE_HANDLE get_handle (void) const; - - /// Perform termination activities when {this} is removed from the - /// {reactor}. - virtual int handle_close (ACE_HANDLE = ACE_INVALID_HANDLE, - ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK); - - /// Accept one connection from a client and activates the - /// SVC_HANDLER. - virtual int handle_input (ACE_HANDLE); - - /// Called when an acceptor times out... - virtual int handle_timeout (const ACE_Time_Value &tv, - const void *arg); - - // = Dynamic linking hooks. - /// Default version does no work and returns -1. Must be overloaded - /// by application developer to do anything meaningful. - virtual int init (int argc, ACE_TCHAR *argv[]); - - /// Default version does no work and returns -1. Must be overloaded - /// by application developer to do anything meaningful. - virtual int fini (void); - - /// Default version returns address info in {buf}. - virtual int info (ACE_TCHAR **, size_t) const; - - // = Service management hooks. - /// Default version does no work and returns -1. Must be overloaded - /// by application developer to do anything meaningful. - virtual int suspend (void); - - /// Default version does no work and returns -1. Must be overloaded - /// by application developer to do anything meaningful. - virtual int resume (void); - -private: - /** - * Insert ourselves into the {ACE_Reactor} so that we can continue - * accepting this connection asynchronously. This method should NOT - * be called by developers directly. - */ - int register_handler (SVC_HANDLER *svc_handler, - const ACE_Synch_Options &options, - bool restart); - - /// Hold the svc_handler_ across asynchrony boundaries. - SVC_HANDLER *svc_handler_; - - /// Hold the restart flag across asynchrony boundaries. - bool restart_; - - /// Factory that establishes connections passively. - PEER_ACCEPTOR peer_acceptor_; - - /// Concurrency strategy for an Acceptor. - ACE_Concurrency_Strategy *concurrency_strategy_; - - /// true if Acceptor created the concurrency strategy and thus should - /// delete it, else false. - bool delete_concurrency_strategy_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Acceptor.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Acceptor.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_ACCEPTOR_H */ diff --git a/deps/acelite/ace/Activation_Queue.cpp b/deps/acelite/ace/Activation_Queue.cpp deleted file mode 100644 index 61683993c..000000000 --- a/deps/acelite/ace/Activation_Queue.cpp +++ /dev/null @@ -1,136 +0,0 @@ -#include "ace/Activation_Queue.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Activation_Queue.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Log_Category.h" -#include "ace/Method_Request.h" -#include "ace/Malloc_Base.h" -#include "ace/Time_Value.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE (ACE_Activation_Queue) - -void -ACE_Activation_Queue::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("delete_queue_ = %d\n"), - this->delete_queue_)); - ACELIB_DEBUG ((LM_INFO, ACE_TEXT ("queue_:\n"))); - if (this->queue_) - this->queue_->dump(); - else - //FUZZ: disable check_for_NULL - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(NULL)\n"))); - //FUZZ: enable check_for_NULL - - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Activation_Queue::ACE_Activation_Queue (ACE_Message_Queue *new_queue, - ACE_Allocator *alloc, - ACE_Allocator *db_alloc) - : delete_queue_ (false) - , allocator_(alloc) - , data_block_allocator_(db_alloc) -{ - if (this->allocator_ == 0) - this->allocator_ = ACE_Allocator::instance (); - - if (new_queue) - this->queue_ = new_queue; - else - { - ACE_NEW (this->queue_, - ACE_Message_Queue); - this->delete_queue_ = true; - } -} - -void -ACE_Activation_Queue::queue (ACE_Message_Queue *q) -{ - // Destroy the internal queue if one exist. - if (this->delete_queue_) - { - // Destroy the current queue. - delete this->queue_; - - // Set the flag to false. NOTE that the delete_queue_ flag is a - // flag used to only indicate whether or not if an internal - // ACE_Message_Queue has been created, therefore, it will not - // affect the user if the user decided to replace the queue with - // their own queue no matter how many time they call on this - // function. - this->delete_queue_ = false; - } - - queue_ = q; -} - -ACE_Activation_Queue::~ACE_Activation_Queue (void) -{ - if (this->delete_queue_) - delete this->queue_; -} - -ACE_Method_Request * -ACE_Activation_Queue::dequeue (ACE_Time_Value *tv) -{ - ACE_Message_Block *mb = 0; - - // Dequeue the message. - if (this->queue_->dequeue_head (mb, tv) != -1) - { - // Get the next . - ACE_Method_Request *mr = - reinterpret_cast (mb->base ()); - // Delete the message block. - mb->release (); - return mr; - } - else - return 0; -} - -int -ACE_Activation_Queue::enqueue (ACE_Method_Request *mr, - ACE_Time_Value *tv) -{ - ACE_Message_Block *mb = 0; - - // We pass sizeof (*mr) here so that flow control will work - // correctly. Since we also pass note that no unnecessary - // memory is actually allocated -- just the size field is set. - ACE_NEW_MALLOC_RETURN (mb, - static_cast (this->allocator_->malloc (sizeof (ACE_Message_Block))), - ACE_Message_Block (sizeof (*mr), // size - ACE_Message_Block::MB_DATA, // type - 0, // cont - (char *) mr, // data - 0, // allocator - 0, // locking strategy - mr->priority (), // priority - ACE_Time_Value::zero, // execution time - ACE_Time_Value::max_time, // absolute time of deadline - this->data_block_allocator_, // data_block allocator - this->allocator_), // message_block allocator - -1); - - // Enqueue in priority order. - int const result = this->queue_->enqueue_prio (mb, tv); - - // Free ACE_Message_Block if enqueue_prio failed. - if (result == -1) - ACE_DES_FREE (mb, this->allocator_->free, ACE_Message_Block); - - return result; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Activation_Queue.h b/deps/acelite/ace/Activation_Queue.h deleted file mode 100644 index 2dbc37ab0..000000000 --- a/deps/acelite/ace/Activation_Queue.h +++ /dev/null @@ -1,167 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Activation_Queue.h - * - * @author Andres Kruse - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_ACTIVATION_QUEUE_H -#define ACE_ACTIVATION_QUEUE_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Message_Queue.h" -#include "ace/Copy_Disabled.h" -#include "ace/Condition_Thread_Mutex.h" - -/// Define to be compatible with the terminology in the POSA2 book! -#define ACE_Activation_List ACE_Activation_Queue - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Method_Request; - -/** - * @class ACE_Activation_Queue - * - * @brief - * Reifies a method into a request. Subclasses typically - * represent necessary state and behavior. - * - * Maintains a priority-ordered queue of ACE_Method_Request objects. - * A scheduler class (often derived from ACE_Task) subsequently removes - * each method request and invokes its @c call() method. - * - * This class is discussed in depth in the Active Object chapter - * of POSA2. In that book, it is referred to as an Activation List. - * - * @sa ACE_Method_Request - */ -class ACE_Export ACE_Activation_Queue -{ -public: - /// Constructor. - /** - * Initializes a new activation queue. - * - * @param new_queue The activation queue uses an ACE_Message_Queue to - * queue and order the method requests. If this argument - * is 0, a new ACE_Message_Queue is created for this - * object's use and will be deleted when this object is - * destroyed. If a non-zero pointer is supplied, the - * passed object will be used and will not be deleted when - * this object is destroyed. If an ACE_Task is being created - * to act as the scheduler, for instance, its - * ACE_Message_Queue pointer can be passed to this object. - * @param alloc Optional, the allocator to use when allocating - * ACE_Message_Block instances that wrap the method requests - * queued to this activation queue. Defaults to - * ACE_Allocator::instance(). - * @param db_alloc Optional, the allocator to use when allocating - * data blocks for the ACE_Message_Block instances that - * wrap the method requests queued to this activation queue. - * Defaults to ACE_Allocator::instance(). - */ - ACE_Activation_Queue (ACE_Message_Queue *new_queue = 0, - ACE_Allocator *alloc = 0, - ACE_Allocator *db_alloc = 0); - - /// Destructor. - virtual ~ACE_Activation_Queue (void); - - // = Activate Queue operations. - - /// Dequeue the next available ACE_Method_Request. - /** - * @param tv If 0, the method will block until a method request is - * available, else will wait until the absolute time specified - * in the referenced ACE_Time_Value. This method will return, - * earlier, however, if queue is closed, deactivated, or when - * a signal occurs. - * - * @retval Pointer to the dequeued ACE_Method_Request object. - * @retval 0 an error occurs; errno contains further information. If - * the specified timeout elapses, errno will be @c EWOULDBLOCK. - */ - ACE_Method_Request *dequeue (ACE_Time_Value *tv = 0); - - /// Enqueue the ACE_Method_Request in priority order. - /** - * The priority of the method request is obtained via the @c priority() - * method of the queued method request. Priority ordering is determined - * by the ACE_Message_Queue class; 0 is the lowest priority. - * - * @param new_method_request Pointer to the ACE_Method_Request object to - * queue. This object's @c priority() method is called to obtain - * the priority. - * @param tv If 0, the method will block until the method request can - * be queued, else will wait until the absolute time specified - * in the referenced ACE_Time_Value. This method will return, - * earlier, however, if queue is closed, deactivated, or when - * a signal occurs. - * - * @retval >0 The number of method requests on the queue after adding - * the specified request. - * @retval -1 if an error occurs; errno contains further information. If - * the specified timeout elapses, errno will be @c EWOULDBLOCK. - */ - int enqueue (ACE_Method_Request *new_method_request, ACE_Time_Value *tv = 0); - - /// Get the current number of method objects in the queue. - size_t method_count (void) const; - - /// Returns 1 if the queue is empty, 0 otherwise. - int is_empty (void) const; - - /// Returns 1 if the queue is full, 0 otherwise. - int is_full (void) const; - - /// Dump the state of an request. - void dump (void) const; - - /// Get a pointer to the underlying queue. - ACE_Message_Queue *queue (void) const; - - /// Set the pointer to the underlying queue. - void queue (ACE_Message_Queue *q); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - - /// Stores the Method_Requests. - ACE_Message_Queue *queue_; - - /// Keeps track of whether we need to delete the queue. - bool delete_queue_; - -private: - /// Allocation strategy of the queue. - ACE_Allocator *allocator_; - - /// Allocation strategy of the message blocks. - ACE_Allocator *data_block_allocator_; - - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Activation_Queue &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Activation_Queue (const ACE_Activation_Queue &)) -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Activation_Queue.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_ACTIVATION_QUEUE_H */ diff --git a/deps/acelite/ace/Activation_Queue.inl b/deps/acelite/ace/Activation_Queue.inl deleted file mode 100644 index b464dbdef..000000000 --- a/deps/acelite/ace/Activation_Queue.inl +++ /dev/null @@ -1,28 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE size_t -ACE_Activation_Queue::method_count (void) const -{ - return queue_->message_count (); -} - -ACE_INLINE int -ACE_Activation_Queue::is_full (void) const -{ - return queue_->is_full (); -} - -ACE_INLINE int -ACE_Activation_Queue::is_empty (void) const -{ - return queue_->is_empty (); -} - -ACE_INLINE ACE_Message_Queue * -ACE_Activation_Queue::queue (void) const -{ - return queue_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Active_Map_Manager.cpp b/deps/acelite/ace/Active_Map_Manager.cpp deleted file mode 100644 index b8813a0dd..000000000 --- a/deps/acelite/ace/Active_Map_Manager.cpp +++ /dev/null @@ -1,5 +0,0 @@ -#include "ace/Active_Map_Manager.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Active_Map_Manager.inl" -#endif /* __ACE_INLINE__ */ diff --git a/deps/acelite/ace/Active_Map_Manager.h b/deps/acelite/ace/Active_Map_Manager.h deleted file mode 100644 index 3bf29130b..000000000 --- a/deps/acelite/ace/Active_Map_Manager.h +++ /dev/null @@ -1,113 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Active_Map_Manager.h - * - * @author Irfan Pyarali - */ -//============================================================================= - - -#ifndef ACE_ACTIVE_MAP_MANAGER_H -#define ACE_ACTIVE_MAP_MANAGER_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Basic_Types.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Active_Map_Manager_Key - * - * @brief Key used in the Active Object Map. - * - * This key keeps information of the index and the generation - * count of the slot it represents. Since the index information - * is part of the key, lookups are super fast and predictable, - */ -class ACE_Export ACE_Active_Map_Manager_Key -{ -public: - /// Default constructor. - ACE_Active_Map_Manager_Key (void); - - /** - * Constructor given the @a slot_index and @a slot_generation number. - * This is useful once the user has somehow recovered the - * @a slot_index and @a slot_generation number from the client. - */ - ACE_Active_Map_Manager_Key (ACE_UINT32 slot_index, - ACE_UINT32 slot_generation); - - /// Get the slot_index. - ACE_UINT32 slot_index (void) const; - - /// Set the slot_index. - void slot_index (ACE_UINT32 i); - - /// Get the slot_generation number. - ACE_UINT32 slot_generation (void) const; - - /// Set the slot_generation number. - void slot_generation (ACE_UINT32 g); - - /// Size required to store information about active key. - static size_t size (void); - - /// Recover state of active key from @a data. User must make sure - /// that @a data encoded using the encode() method. - void decode (const void *data); - - /// Encode state of the active key into @a data. @a data must be as - /// big as the value returned from size(). - void encode (void *data) const; - - /// Compare keys. - bool operator== (const ACE_Active_Map_Manager_Key &rhs) const; - bool operator!= (const ACE_Active_Map_Manager_Key &rhs) const; - - // = This really should be protected but because of template - // friends, they are not. - - /// Increment the slot_generation number. - void increment_slot_generation_count (void); - -private: - /** - * @brief Data for the Active Object Map Key. - * - * This separate structure makes it easier to manage copying - * the index and the generation to and from the user buffer. - * - */ - struct key_data - { - /// Slot index in the active map. - ACE_UINT32 slot_index_; - - /// Slot generation number of @c slot_index_ slot in the active map. - ACE_UINT32 slot_generation_; - }; - - /// Data for the Active Object Map Key. - key_data key_data_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Active_Map_Manager.inl" -#endif /* __ACE_INLINE__ */ - -// Include the templates here. -#include "ace/Active_Map_Manager_T.h" - -#include /**/ "ace/post.h" -#endif /* ACE_ACTIVE_MAP_MANAGER_H */ diff --git a/deps/acelite/ace/Active_Map_Manager.inl b/deps/acelite/ace/Active_Map_Manager.inl deleted file mode 100644 index 2fc8c13e5..000000000 --- a/deps/acelite/ace/Active_Map_Manager.inl +++ /dev/null @@ -1,92 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Active_Map_Manager_Key::ACE_Active_Map_Manager_Key (void) -{ - // If you change ~0, please change ACE_Map_Manager::free_list_id() - // accordingly. - this->key_data_.slot_index_ = (ACE_UINT32) ~0; - this->key_data_.slot_generation_ = 0; -} - -ACE_INLINE -ACE_Active_Map_Manager_Key::ACE_Active_Map_Manager_Key (ACE_UINT32 slot_index, - ACE_UINT32 slot_generation) -{ - this->key_data_.slot_index_ = slot_index; - this->key_data_.slot_generation_ = slot_generation; -} - -ACE_INLINE ACE_UINT32 -ACE_Active_Map_Manager_Key::slot_index (void) const -{ - return this->key_data_.slot_index_; -} - -ACE_INLINE ACE_UINT32 -ACE_Active_Map_Manager_Key::slot_generation (void) const -{ - return this->key_data_.slot_generation_; -} - -ACE_INLINE bool -ACE_Active_Map_Manager_Key::operator== (const ACE_Active_Map_Manager_Key &rhs) const -{ - return - this->key_data_.slot_index_ == rhs.key_data_.slot_index_ && - this->key_data_.slot_generation_ == rhs.key_data_.slot_generation_; -} - -ACE_INLINE bool -ACE_Active_Map_Manager_Key::operator!= (const ACE_Active_Map_Manager_Key &rhs) const -{ - return !this->operator== (rhs); -} - -ACE_INLINE void -ACE_Active_Map_Manager_Key::slot_index (ACE_UINT32 i) -{ - this->key_data_.slot_index_ = i; -} - -ACE_INLINE void -ACE_Active_Map_Manager_Key::slot_generation (ACE_UINT32 g) -{ - this->key_data_.slot_generation_ = g; -} - -ACE_INLINE void -ACE_Active_Map_Manager_Key::increment_slot_generation_count (void) -{ - ++this->key_data_.slot_generation_; -} - -/* static */ -ACE_INLINE size_t -ACE_Active_Map_Manager_Key::size (void) -{ - return sizeof (ACE_UINT32) + sizeof (ACE_UINT32); -} - -ACE_INLINE void -ACE_Active_Map_Manager_Key::decode (const void *data) -{ - // Copy the information from the user buffer into the key. - ACE_OS::memcpy (&this->key_data_, - data, - sizeof this->key_data_); -} - -ACE_INLINE void -ACE_Active_Map_Manager_Key::encode (void *data) const -{ - // Copy the key data to the user buffer. - ACE_OS::memcpy (data, - &this->key_data_, - sizeof this->key_data_); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Active_Map_Manager_T.cpp b/deps/acelite/ace/Active_Map_Manager_T.cpp deleted file mode 100644 index 6341ca711..000000000 --- a/deps/acelite/ace/Active_Map_Manager_T.cpp +++ /dev/null @@ -1,20 +0,0 @@ -#ifndef ACE_ACTIVE_MAP_MANAGER_T_CPP -#define ACE_ACTIVE_MAP_MANAGER_T_CPP - -#include "ace/Active_Map_Manager_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (__ACE_INLINE__) -#include "ace/Active_Map_Manager_T.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Active_Map_Manager) - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_ACTIVE_MAP_MANAGER_T_CPP */ diff --git a/deps/acelite/ace/Active_Map_Manager_T.h b/deps/acelite/ace/Active_Map_Manager_T.h deleted file mode 100644 index 472ea7191..000000000 --- a/deps/acelite/ace/Active_Map_Manager_T.h +++ /dev/null @@ -1,206 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Active_Map_Manager_T.h - * - * @author Irfan Pyarali - */ -//============================================================================= - - -#ifndef ACE_ACTIVE_MAP_MANAGER_T_H -#define ACE_ACTIVE_MAP_MANAGER_T_H -#include /**/ "ace/pre.h" - -#include "ace/Map_Manager.h" -#include "ace/Active_Map_Manager.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Null_Mutex.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Active_Map_Manager - * - * @brief Define a map abstraction that associates system generated - * keys with user specified values. - * - * Since the key is system generated, searches are very fast and - * take a constant amount of time. - */ -template -class ACE_Active_Map_Manager : public ACE_Map_Manager -{ -public: - // = Traits. - typedef ACE_Active_Map_Manager_Key key_type; - typedef T mapped_type; - - typedef ACE_Map_Entry ENTRY; - typedef ACE_Map_Iterator ITERATOR; - typedef ACE_Map_Reverse_Iterator REVERSE_ITERATOR; - - typedef ENTRY entry; - typedef ITERATOR iterator; - typedef REVERSE_ITERATOR reverse_iterator; - - /// Initialize a Active_Map_Manager with the ACE_DEFAULT_MAP_SIZE. - ACE_Active_Map_Manager (ACE_Allocator *alloc = 0); - - /// Initialize a Active_Map_Manager with @a size entries. - ACE_Active_Map_Manager (size_t size, - ACE_Allocator *alloc = 0); - - /// Close down a Active_Map_Manager and release dynamically - /// allocated resources. - ~ACE_Active_Map_Manager (void); - - /// Initialize a Active_Map_Manager with size @a length. - int open (size_t length = ACE_DEFAULT_MAP_SIZE, - ACE_Allocator *alloc = 0); - - /// Close down a Active_Map_Manager and release dynamically - /// allocated resources. - int close (void); - - /// Add @a value to the map, and the corresponding key produced by the - /// Active_Map_Manager is returned through @a key. - int bind (const T &value, - ACE_Active_Map_Manager_Key &key); - - /// Add @a value to the map. The user does not care about the - /// corresponding key produced by the Active_Map_Manager. - int bind (const T &value); - - /** - * Reserves a slot in the internal structure and returns the key and - * a pointer to the value. User should place their @a value into - * @a internal_value. This method is useful in reducing the number - * of copies required in some cases. Note that @a internal_value is - * only a temporary pointer and will change when the map resizes. - * Therefore, the user should use the pointer immediately and not - * hold on to it. - */ - int bind (ACE_Active_Map_Manager_Key &key, - T *&internal_value); - - /// Reassociate @a key with @a value. The function fails if @a key is - /// not in the map. - int rebind (const ACE_Active_Map_Manager_Key &key, - const T &value); - - /** - * Reassociate @a key with @a value, storing the old value into the - * "out" parameter @a old_value. The function fails if @a key is not - * in the map. - */ - int rebind (const ACE_Active_Map_Manager_Key &key, - const T &value, - T &old_value); - - /** - * Reassociate @a key with @a value, storing the old key and value - * into the "out" parameter @a old_key and @a old_value. The function - * fails if @a key is not in the map. - */ - int rebind (const ACE_Active_Map_Manager_Key &key, - const T &value, - ACE_Active_Map_Manager_Key &old_key, - T &old_value); - - /// Locate @a value associated with @a key. - int find (const ACE_Active_Map_Manager_Key &key, - T &value) const; - - /// Is @a key in the map? - int find (const ACE_Active_Map_Manager_Key &key) const; - - /** - * Locate @a value associated with @a key. The value is returned via - * @a internal_value and hence a copy is saved. Note that - * @a internal_value is only a temporary pointer and will change when - * the map resizes. Therefore, the user should use the pointer - * immediately and not hold on to it. - */ - int find (const ACE_Active_Map_Manager_Key &key, - T *&internal_value) const; - - // Creates a key. User should place their @a value into - // <*internal_value>. This method is useful in reducing the number - // of copies required in some cases. - - /// Remove @a key from the map. - int unbind (const ACE_Active_Map_Manager_Key &key); - - /// Remove @a key from the map, and return the @a value associated with - /// @a key. - int unbind (const ACE_Active_Map_Manager_Key &key, - T &value); - - /** - * Locate @a value associated with @a key. The value is returned via - * @a internal_value and hence a copy is saved. Note that - * @a internal_value is only a temporary pointer and will change when - * the map resizes or when this slot is reused. Therefore, the user - * should use the pointer immediately and not hold on to it. - */ - int unbind (const ACE_Active_Map_Manager_Key &key, - T *&internal_value); - - /// Return the current size of the map. - size_t current_size (void) const; - - /// Return the total size of the map. - size_t total_size (void) const; - - /// Returns a key that cannot be found in the map. - static const ACE_Active_Map_Manager_Key npos (void); - - /// Dump the state of an object. - void dump (void) const; - - // = STL styled iterator factory functions. - - /// Return forward iterator. - ACE_Map_Iterator begin (void); - ACE_Map_Iterator end (void); - - /// Return reverse iterator. - ACE_Map_Reverse_Iterator rbegin (void); - ACE_Map_Reverse_Iterator rend (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - - /// Private base class - typedef ACE_Map_Manager ACE_AMM_BASE; - -private: - // = Disallow these operations. - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Active_Map_Manager &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Active_Map_Manager (const ACE_Active_Map_Manager &)) -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Active_Map_Manager_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Active_Map_Manager_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Active_Map_Manager_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_ACTIVE_MAP_MANAGER_T_H */ diff --git a/deps/acelite/ace/Active_Map_Manager_T.inl b/deps/acelite/ace/Active_Map_Manager_T.inl deleted file mode 100644 index c8a6caf9b..000000000 --- a/deps/acelite/ace/Active_Map_Manager_T.inl +++ /dev/null @@ -1,308 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE int -ACE_Active_Map_Manager::bind (ACE_Active_Map_Manager_Key &key, - T *&internal_value) -{ - ACE_UINT32 slot_index; - int result = this->next_free (slot_index); - - if (result == 0) - { - // Move from free list to occupied list - this->move_from_free_list_to_occupied_list (slot_index); - - // Reset the key. - this->search_structure_[slot_index].ext_id_.increment_slot_generation_count (); - this->search_structure_[slot_index].ext_id_.slot_index (slot_index); - - // Copy the key for the user. - key = this->search_structure_[slot_index].ext_id_; - - // This is where the user should place the value. - internal_value = &this->search_structure_[slot_index].int_id_; - - // Update the current size. - ++this->cur_size_; - } - - return result; -} - -template ACE_INLINE int -ACE_Active_Map_Manager::bind (const T &value, - ACE_Active_Map_Manager_Key &key) -{ - T *internal_value = 0; - int result = this->bind (key, - internal_value); - - if (result == 0) - { - // Store new value. - *internal_value = value; - } - - return result; -} - -template ACE_INLINE int -ACE_Active_Map_Manager::bind (const T &value) -{ - ACE_Active_Map_Manager_Key key; - return this->bind (value, key); -} - -template ACE_INLINE int -ACE_Active_Map_Manager::find (const ACE_Active_Map_Manager_Key &key, - T *&internal_value) const -{ - ACE_UINT32 slot_index = key.slot_index (); - ACE_UINT32 slot_generation = key.slot_generation (); - - if (slot_index > this->total_size_ || -#if defined (ACE_HAS_LAZY_MAP_MANAGER) - this->search_structure_[slot_index].free_ || -#endif /* ACE_HAS_LAZY_MAP_MANAGER */ - this->search_structure_[slot_index].ext_id_.slot_generation () != slot_generation || - this->search_structure_[slot_index].ext_id_.slot_index () == - (ACE_UINT32)this->free_list_id ()) - { - return -1; - } - else - { - // This is where the user value is. - internal_value = &this->search_structure_[slot_index].int_id_; - } - - return 0; -} - -template ACE_INLINE int -ACE_Active_Map_Manager::find (const ACE_Active_Map_Manager_Key &key) const -{ - T *internal_value = 0; - return this->find (key, - internal_value); -} - -template ACE_INLINE int -ACE_Active_Map_Manager::find (const ACE_Active_Map_Manager_Key &key, - T &value) const -{ - T *internal_value = 0; - int result = this->find (key, - internal_value); - - if (result == 0) - value = *internal_value; - - return result; -} - -template ACE_INLINE int -ACE_Active_Map_Manager::rebind (const ACE_Active_Map_Manager_Key &key, - const T &value) -{ - int result = this->find (key); - - if (result == 0) - { - // Store new value. - this->search_structure_[key.slot_index ()].int_id_ = value; - } - - return result; -} - -template ACE_INLINE int -ACE_Active_Map_Manager::rebind (const ACE_Active_Map_Manager_Key &key, - const T &value, - T &old_value) -{ - int result = this->find (key); - - if (result == 0) - { - // Copy old value. - old_value = this->search_structure_[key.slot_index ()].int_id_; - - // Store new value. - this->search_structure_[key.slot_index ()].int_id_ = value; - } - - return result; -} - -template ACE_INLINE int -ACE_Active_Map_Manager::rebind (const ACE_Active_Map_Manager_Key &key, - const T &value, - ACE_Active_Map_Manager_Key &old_key, - T &old_value) -{ - int result = this->find (key); - - if (result == 0) - { - // Copy old key. - old_key = this->search_structure_[key.slot_index ()].ext_id_; - - // Copy old value. - old_value = this->search_structure_[key.slot_index ()].int_id_; - - // Store new value. - this->search_structure_[key.slot_index ()].int_id_ = value; - } - - return result; -} - -template ACE_INLINE int -ACE_Active_Map_Manager::unbind (const ACE_Active_Map_Manager_Key &key, - T *&internal_value) -{ - int result = this->find (key, - internal_value); - - if (result == 0) - { - ACE_UINT32 slot_index = key.slot_index (); - -#if defined (ACE_HAS_LAZY_MAP_MANAGER) - - // - // In the case of lazy map managers, the movement of free slots - // from the occupied list to the free list is delayed until we - // run out of free slots in the free list. - // - - this->search_structure_[slot_index].free_ = 1; - -#else - - // Move from occupied list to free list. - this->move_from_occupied_list_to_free_list (slot_index); - -#endif /* ACE_HAS_LAZY_MAP_MANAGER */ - - // Reset the slot_index. This will tell us that this entry is free. - this->search_structure_[slot_index].ext_id_.slot_index (this->free_list_id ()); - - // Update the current size. - --this->cur_size_; - } - - return result; -} - -template ACE_INLINE int -ACE_Active_Map_Manager::unbind (const ACE_Active_Map_Manager_Key &key, - T &value) -{ - T *internal_value; - int result = this->unbind (key, - internal_value); - - if (result == 0) - { - // Copy old value. - value = *internal_value; - } - - return result; -} - -template ACE_INLINE int -ACE_Active_Map_Manager::unbind (const ACE_Active_Map_Manager_Key &key) -{ - T *internal_value; - return this->unbind (key, - internal_value); -} - -template ACE_INLINE -ACE_Active_Map_Manager::ACE_Active_Map_Manager (ACE_Allocator *alloc) - : ACE_AMM_BASE (alloc) -{ -} - -template ACE_INLINE -ACE_Active_Map_Manager::ACE_Active_Map_Manager (size_t size, - ACE_Allocator *alloc) - : ACE_AMM_BASE (size, - alloc) -{ -} - -template ACE_INLINE -ACE_Active_Map_Manager::~ACE_Active_Map_Manager (void) -{ -} - -template ACE_INLINE int -ACE_Active_Map_Manager::open (size_t length, - ACE_Allocator *alloc) -{ - return ACE_AMM_BASE::open (length, alloc); -} - -template ACE_INLINE int -ACE_Active_Map_Manager::close (void) -{ - return ACE_AMM_BASE::close (); -} - -template ACE_INLINE size_t -ACE_Active_Map_Manager::current_size (void) const -{ - return ACE_AMM_BASE::current_size (); -} - -template ACE_INLINE size_t -ACE_Active_Map_Manager::total_size (void) const -{ - return ACE_AMM_BASE::total_size (); -} - -/* static */ -template ACE_INLINE const ACE_Active_Map_Manager_Key -ACE_Active_Map_Manager::npos (void) -{ - return ACE_Active_Map_Manager_Key (~0, ~0); -} - -template ACE_INLINE void -ACE_Active_Map_Manager::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_AMM_BASE::dump (); -#endif /* ACE_HAS_DUMP */ -} - -template ACE_Map_Iterator -ACE_Active_Map_Manager::begin (void) -{ - return ACE_AMM_BASE::begin (); -} - -template ACE_INLINE ACE_Map_Iterator -ACE_Active_Map_Manager::end (void) -{ - return ACE_AMM_BASE::end (); -} - -template ACE_INLINE ACE_Map_Reverse_Iterator -ACE_Active_Map_Manager::rbegin (void) -{ - return ACE_AMM_BASE::rbegin (); -} - -template ACE_INLINE ACE_Map_Reverse_Iterator -ACE_Active_Map_Manager::rend (void) -{ - return ACE_AMM_BASE::rend (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Addr.cpp b/deps/acelite/ace/Addr.cpp deleted file mode 100644 index 85f3523cf..000000000 --- a/deps/acelite/ace/Addr.cpp +++ /dev/null @@ -1,68 +0,0 @@ -#include "ace/Addr.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Addr.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Log_Category.h" -#include "ace/os_include/sys/os_socket.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Note: this object requires static construction and destruction. -/* static */ -const ACE_Addr ACE_Addr::sap_any (AF_ANY, -1); - -ACE_ALLOC_HOOK_DEFINE(ACE_Addr) - - -// Initializes instance variables. Note that 0 is an unspecified -// protocol family type... - -ACE_Addr::ACE_Addr (int type, int size) : - addr_type_ (type), - addr_size_ (size) -{ -} - -ACE_Addr::~ACE_Addr (void) -{ -} - -void * -ACE_Addr::get_addr (void) const -{ - return 0; -} - -void -ACE_Addr::set_addr (const void *, int) -{ -} - -// Initializes instance variables. - -void -ACE_Addr::base_set (int type, int size) -{ - this->addr_type_ = type; - this->addr_size_ = size; -} - -void -ACE_Addr::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Addr::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("addr_type_ = %d"), this->addr_type_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\naddr_size_ = %d"), this->addr_size_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Addr.h b/deps/acelite/ace/Addr.h deleted file mode 100644 index e7760cd2f..000000000 --- a/deps/acelite/ace/Addr.h +++ /dev/null @@ -1,100 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Addr.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_ADDR_H -#define ACE_ADDR_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Addr - * - * @brief Defines the base class for the "address family independent" - * address format. - */ -class ACE_Export ACE_Addr -{ -public: - /// Initializes instance variables. - ACE_Addr (int type = -1, int size = -1); - - /// Destructor. - virtual ~ACE_Addr (void); - - // = Get/set the size of the address. - - /// Return the size of the address. - int get_size (void) const; - - /// Sets the size of the address. - void set_size (int size); - - // = Get/set the type of the address. - - /// Get the type of the address. - int get_type (void) const; - - /// Set the type of the address. - void set_type (int type); - - /// Return a pointer to the address. - virtual void *get_addr (void) const; - - /// Set a pointer to the address. - virtual void set_addr (const void *, int len); - - // = Equality/inequality tests - /// Check for address equality. - bool operator == (const ACE_Addr &sap) const; - - /// Check for address inequality. - bool operator != (const ACE_Addr &sap) const; - - /// Initializes instance variables. - void base_set (int type, int size); - - /// Wild-card address. - static const ACE_Addr sap_any; - - /// Returns a hash value. This should be overwritten by a subclass - /// that can produce a better hash value. - virtual unsigned long hash (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// e.g., AF_UNIX, AF_INET, AF_SPIPE, etc. - int addr_type_; - - /// Number of bytes in the address. - int addr_size_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Addr.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* ACE_ADDR_H */ diff --git a/deps/acelite/ace/Addr.inl b/deps/acelite/ace/Addr.inl deleted file mode 100644 index ad6f03e21..000000000 --- a/deps/acelite/ace/Addr.inl +++ /dev/null @@ -1,54 +0,0 @@ -// -*- C++ -*- -// Return the address of the address. - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE bool -ACE_Addr::operator == (const ACE_Addr &sap) const -{ - return (sap.addr_type_ == this->addr_type_ && - sap.addr_size_ == this->addr_size_ ); -} - -ACE_INLINE bool -ACE_Addr::operator != (const ACE_Addr &sap) const -{ - return (sap.addr_type_ != this->addr_type_ || - sap.addr_size_ != this->addr_size_ ); -} - -/// Return the size of the address. -ACE_INLINE int -ACE_Addr::get_size (void) const -{ - return this->addr_size_; -} - -/// Sets the size of the address. -ACE_INLINE void -ACE_Addr::set_size (int size) -{ - this->addr_size_ = size; -} - -/// Return the type of the address. -ACE_INLINE int -ACE_Addr::get_type (void) const -{ - return this->addr_type_; -} - -/// Set the type of the address. -ACE_INLINE void -ACE_Addr::set_type (int type) -{ - this->addr_type_ = type; -} - -ACE_INLINE unsigned long -ACE_Addr::hash (void) const -{ - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Arg_Shifter.cpp b/deps/acelite/ace/Arg_Shifter.cpp deleted file mode 100644 index 29eace272..000000000 --- a/deps/acelite/ace/Arg_Shifter.cpp +++ /dev/null @@ -1,223 +0,0 @@ -#ifndef ACE_ARG_SHIFTER_T_CPP -#define ACE_ARG_SHIFTER_T_CPP - -#include "ace/Arg_Shifter.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_NS_strings.h" -#include "ace/OS_Errno.h" -#include "ace/OS_Memory.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Arg_Shifter_T::ACE_Arg_Shifter_T (int& argc, - const CHAR_TYPE** argv, - const CHAR_TYPE** temp) - : argc_ (argc), - total_size_ (argc), - temp_ (temp), - argv_ (argv), - current_index_ (0), - back_ (argc - 1), - front_ (0) -{ - this->init (); -} - -template -ACE_Arg_Shifter_T::ACE_Arg_Shifter_T (int& argc, - CHAR_TYPE** argv, - CHAR_TYPE** temp) - : argc_ (argc), - total_size_ (argc), - temp_ ((const CHAR_TYPE **) temp), - argv_ ((const CHAR_TYPE **) argv), - current_index_ (0), - back_ (argc - 1), - front_ (0) -{ - this->init (); -} - -template -void -ACE_Arg_Shifter_T::init (void) -{ - // If not provided with one, allocate a temporary array. - if (this->temp_ == 0) -#if defined (ACE_HAS_ALLOC_HOOKS) - this->temp_ = reinterpret_cast - (ACE_Allocator::instance ()->malloc (sizeof (CHAR_TYPE*) * this->total_size_)); -#else - ACE_NEW (this->temp_, - const CHAR_TYPE *[this->total_size_]); -#endif /* ACE_HAS_ALLOC_HOOKS */ - if (this->temp_ != 0) - { - // Fill the temporary array. - this->argc_ = 0; - for (int i = 0; i < this->total_size_; i++) - { - this->temp_[i] = this->argv_[i]; - this->argv_[i] = 0; - } - } - else - { - // Allocation failed, prohibit iteration. - this->current_index_ = this->argc_; - this->front_ = this->argc_; - } -} - -template -ACE_Arg_Shifter_T::~ACE_Arg_Shifter_T (void) -{ - // Delete the temporary vector. -#if defined (ACE_HAS_ALLOC_HOOKS) - if (this->temp_) - ACE_Allocator::instance ()->free (this->temp_); -#else - delete [] temp_; -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -template -const CHAR_TYPE * -ACE_Arg_Shifter_T::get_current (void) const -{ - const CHAR_TYPE * retval = 0; - - if (this->is_anything_left ()) - retval = this->temp_[current_index_]; - - return retval; -} - -template -const CHAR_TYPE * -ACE_Arg_Shifter_T::get_the_parameter (const CHAR_TYPE *flag) -{ - // the return 0's abound because this method - // would otherwise be a deep if { } else { } - - // check to see if any arguments still exist - if (!this->is_anything_left()) - return 0; - - // check to see if the flag is the argument - int const offset = this->cur_arg_strncasecmp (flag); - if (offset == -1) - return 0; - - if (offset == 0) - { - this->consume_arg (); - - if (!this->is_parameter_next()) - { - return 0; - } - } - // the parameter is in the middle somewhere... - return this->temp_[current_index_] + offset; -} - -template -int -ACE_Arg_Shifter_T::cur_arg_strncasecmp (const CHAR_TYPE *flag) -{ - if (!this->is_anything_left ()) - return -1; - - const size_t flag_length = ACE_OS::strlen (flag); - const CHAR_TYPE *arg = this->temp_[this->current_index_]; - - if (ACE_OS::strncasecmp (arg, flag, flag_length) != 0) - return -1; - - const size_t arg_length = ACE_OS::strlen (arg); - size_t remaining = flag_length; - while (remaining < arg_length && arg[remaining] == CHAR_TYPE (' ')) - ++remaining; - return (arg_length == flag_length) ? 0 : static_cast (remaining); -} - -template -int -ACE_Arg_Shifter_T::consume_arg (int number) -{ - int retval = 0; - - // Stick knowns at the end of the vector (consumed). - if (this->is_anything_left() >= number) - { - for (int i = 0, j = this->back_ - (number - 1); - i < number; - ++i, ++j, ++this->current_index_) - this->argv_[j] = this->temp_[this->current_index_]; - - this->back_ -= number; - retval = 1; - } - - return retval; -} - -template -int -ACE_Arg_Shifter_T::ignore_arg (int number) -{ - int retval = 0; - - // Keep unknowns at the head of the vector. - if (this->is_anything_left () >= number) - { - for (int i = 0; - i < number; - i++, this->current_index_++, this->front_++) - this->argv_[this->front_] = this->temp_[this->current_index_]; - - retval = 1; - this->argc_ += number; - } - - return retval; -} - -template -int -ACE_Arg_Shifter_T::is_anything_left (void) const -{ - return this->total_size_ - this->current_index_; -} - -template -int -ACE_Arg_Shifter_T::is_option_next (void) const -{ - return this->is_anything_left () && - this->temp_[this->current_index_][0] == '-'; -} - -template -int -ACE_Arg_Shifter_T::is_parameter_next (void) const -{ - return this->is_anything_left () - && this->temp_[this->current_index_][0] != '-'; -} - -template -int -ACE_Arg_Shifter_T::num_ignored_args (void) const -{ - return this->front_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_ATOMIC_OP_T_CPP */ diff --git a/deps/acelite/ace/Arg_Shifter.h b/deps/acelite/ace/Arg_Shifter.h deleted file mode 100644 index 29a6b3451..000000000 --- a/deps/acelite/ace/Arg_Shifter.h +++ /dev/null @@ -1,239 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Arg_Shifter.h - * - * @author Seth Widoff - */ -//============================================================================= - -#ifndef ACE_ARG_SHIFTER_H -#define ACE_ARG_SHIFTER_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Global_Macros.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Arg_Shifter_T - * - * @brief This ADT operates on a specified set of arguments (@a argv). - * As known arguments are scanned, they are shifted to the back of the - * @a argv vector, so deeper levels of argument parsing can locate the yet - * unprocessed arguments at the beginning of the vector. - * - * Nomenclature: - * argument - a member of the argv array - * option - an argument starting with '-' - * flag - synonym for "option" - * parameter value - an argument not starting with '-' - * parameter - synonym for "parameter value" - * - * The @c ACE_Arg_Shifter copies the pointers of the @a argv vector - * into a temporary array, emptying the original. As the @c ACE_Arg_Shifter - * iterates over the temporary array, it places known arguments in the rear - * of the original array and places the unknown ones in the beginning of the - * original array. It modifies argc to be the number of unknown arguments, - * so it looks to the caller as if the original array contains only unknown - * arguments. So, after @c ACE_Arg_Shifter has visited all the arguments - * in the temporary array, the original @a argv array appears to contain - * only the unknown arguments in their original order (but it actually has - * all the known arguments, too, beyond argc). - */ -template -class ACE_Arg_Shifter_T -{ -public: - /** - * Initialize the ACE_Arg_Shifter to the vector over which to - * iterate. Optionally, also provide the temporary array for - * use in shifting the arguments. If ACE_Arg_Shifter must allocate - * the temporary vector internally and dynamic allocation fails, the - * ACE_Arg_Shifter will set all indicators to end of the vector, - * forbidding iteration. Following iteration over @a argv, the - * @a argc value will be updated to contain the number of - * unconsumed arguments. - * @param argc The number of strings in @a argv. @a argc will be - * updated to reflect the number of unconsumed arguments. - * @param argv The argument vector to shift. The string pointers in - * the vector will be reordered to place the @a argc unconsumed - * arguments at the front of the vector. - * @param temp A vector of @c CHAR_TYPE pointers at least @a argc - * elements long. The vector will be used for argument shifting as - * the specified @a argv vector is consumed. The vector must not - * be modified while this object exists. If this argument is 0 - * (the default) the object will allocate and free the temporary - * vector transparently. - */ - ACE_Arg_Shifter_T (int &argc, - const CHAR_TYPE **argv, - const CHAR_TYPE **temp = 0); - - /// Same behavior as the preceding constructor, but without the - /// "const" qualifier. - ACE_Arg_Shifter_T (int &argc, - CHAR_TYPE **argv, - CHAR_TYPE **temp = 0); - - /// Destructor. - ~ACE_Arg_Shifter_T (void); - - /// Get the current head of the vector. - const CHAR_TYPE *get_current (void) const; - - /** - * If the @a flag matches the current_arg of arg shifter - * this method will attempt to return the associated - * parameter value - * - * Safe to call without checking that a current arg exists - * - * In the following examples, a pointer to the char* "value" is returned - * - * eg: main -foobar value, main -FooBar value - * main -FOOBARvalue - * - * all of the above will match the @a flag == -FooBar - * and will return a char* to "value" - * - * main -foobar 4 would succeed and return a char* to "4" - * main -foobar -4 does not succeed (-4 is not a parameter) - * but instead, would return 0 - * - * 0 is returned: - * If the current argument does not match flag - * If there is no parameter found after a 'matched' flag - * - * If the flag is matched and the flag and parameter DO NOT RUN - * together, the flag is consumed, the parameter is returned, - * and the new current argument is the parameter value. - * ie '-foobarflag VALUE' leaves the new cur arg == "VALUE" - * - * If the flag is matched and the flag and parameter RUN - * together '-foobarflagVALUE', the flag is NOT consumed - * and the cur arg is left pointing to the entire flag/value pair - */ - const CHAR_TYPE *get_the_parameter (const CHAR_TYPE *flag); - - /** - * Check if the current argument matches (case insensitive) @a flag - * - * ------------------------------------------------------------ - * - * Case A: Perfect Match (case insensitive) - * 0 is returned. - * - * ie: when current_arg = "-foobar" or "-FOOBAR" or "-fooBAR" - * this->cur_arg_strncasecmp ("-FooBar"); - * will return 0 - * - * ------------------------------------------------------------ - * - * Case B: Perfect Match (case insensitive) but the current_arg - * is longer than the flag. Returns a number equal to the index - * in the char* indicating the start of the extra characters - * after any initial spaces (see below). - * - * ie: when current_arg = "-foobar98023" - * this->cur_arg_strncasecmp ("-FooBar"); - * will return 7 - * - * Spaces separating the flag from its value (that are still part - * of the same argv element) are counted as part of the return value - * - * ie: when current_arg = "-foobar 98023" - * this->cur_arg_strncasecmp ("-FooBar"); - * will return 8 - * - * Notice: this number will always be > 0 - * - * ------------------------------------------------------------ - * - * Case C: If neither of Case A or B is met (no match) - * then -1 is returned - */ - int cur_arg_strncasecmp (const CHAR_TYPE *flag); - - /// Consume @a number argument(s) by sticking them/it on the end of - /// the vector. - int consume_arg (int number = 1); - - /// Place @a number arguments in the same relative order ahead of the - /// known arguments in the vector. - int ignore_arg (int number = 1); - - /// Returns the number of args left to see in the vector. - int is_anything_left (void) const; - - /// Returns 1 if there's a next item in the vector and it begins with - /// '-'. - int is_option_next (void) const; - - /// Returns 1 if there's a next item in the vector and it doesn't - /// begin with '-'. - int is_parameter_next (void) const; - - /// Returns the number of irrelevant args seen. - int num_ignored_args (void) const; - -private: - /// Copy Constructor should not be used. - ACE_UNIMPLEMENTED_FUNC (ACE_Arg_Shifter_T (const ACE_Arg_Shifter_T &)) - - /// Assignment '=' operator should not be used. - ACE_UNIMPLEMENTED_FUNC (ACE_Arg_Shifter_T operator= (const ACE_Arg_Shifter_T &)) - - /// Refactor the constructor logic. - void init (void); - - /// The size of the argument vector. - int &argc_; - - /// The size of argv_. - int total_size_; - - /// The temporary array over which we traverse. - const CHAR_TYPE **temp_; - - /// The array in which the arguments are reordered. - const CHAR_TYPE **argv_; - - /// The element in we're currently examining. - int current_index_; - - /// The index of in which we'll stick the next unknown - /// argument. - int back_; - - /// The index of in which we'll stick the next known - /// argument. - /** This is not really the "front" at all. It's the point after - * which the unknown arguments end and at which the known arguments begin. - */ - int front_; -}; - -typedef ACE_Arg_Shifter_T ACE_Arg_Shifter; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Arg_Shifter.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Arg_Shifter.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_ARG_SHIFTER_H */ diff --git a/deps/acelite/ace/Argv_Type_Converter.cpp b/deps/acelite/ace/Argv_Type_Converter.cpp deleted file mode 100644 index 4c8e4fbb9..000000000 --- a/deps/acelite/ace/Argv_Type_Converter.cpp +++ /dev/null @@ -1,190 +0,0 @@ -#include "ace/Argv_Type_Converter.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Argv_Type_Converter.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/OS_NS_string.h" -#include "ace/OS_Errno.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_USES_WCHAR) -ACE_Argv_Type_Converter::ACE_Argv_Type_Converter (int &argc, wchar_t** argv) - : saved_argc_ (argc), - char_argv_ (0), - wchar_argv_ (argv), - before_pass_argc_ (argc), - original_type_ (true), - wchar_passed_ (false), - char_passed_ (false) -{ - this->initialize (); - - for (int i = 0; i < argc; ++i) - this->char_argv_[i] = ACE_OS::strdup (ACE_TEXT_ALWAYS_CHAR (argv[i])); -} -#endif // ACE_USES_WCHAR - - -ACE_Argv_Type_Converter::ACE_Argv_Type_Converter (int &argc, char **argv) - : saved_argc_(argc), - char_argv_(argv) -#if defined (ACE_USES_WCHAR) - , wchar_argv_(0), - before_pass_argc_(argc), - original_type_(false), - wchar_passed_(false), - char_passed_(false) -{ - this->initialize(); - - for (int i = 0; i < argc; ++i) - this->wchar_argv_[i] = ACE_OS::strdup (ACE_TEXT_ANTI_TO_TCHAR (argv[i])); -} -#else -{ -} -#endif // ACE_USES_WCHAR - -ACE_Argv_Type_Converter::~ACE_Argv_Type_Converter (void) -{ -#if defined (ACE_USES_WCHAR) - // selectively delete the 'copy' of argv - if (this->original_type_) - { - // if original type is wchar_t - if (this->char_passed_) - this->align_wchar_with_char (); - - for (int i = 0; i < this->before_pass_argc_; ++i) - ACE_OS::free (this->char_argv_[i]); - - delete [] this->char_argv_; - } - else - { - // if original type is char - if (this->wchar_passed_) - this->align_char_with_wchar (); - - for (int i = 0; i < this->before_pass_argc_; ++i) - ACE_OS::free (this->wchar_argv_[i]); - - delete [] this->wchar_argv_; - } -#endif // ACE_USES_WCHAR -} - -#if defined (ACE_USES_WCHAR) -void -ACE_Argv_Type_Converter::initialize (void) -{ - if (this->original_type_) - { - // Make a copy of argv in 'char'. type Create one more argv entry - // than original argc for the NULL. - ACE_NEW (char_argv_, - char *[this->saved_argc_ + 1]); - this->char_argv_[saved_argc_] = 0; // last entry of argv is - // always a NULL - } - else - { - // make a copy of argv in 'wchar_t' type - ACE_NEW (this->wchar_argv_, - wchar_t*[this->saved_argc_ + 1]); - this->wchar_argv_[saved_argc_] = 0; - } -} - - -void -ACE_Argv_Type_Converter::align_char_with_wchar (void) -{ - for (int wchar_argv_index = 0; wchar_argv_index < this->saved_argc_; - ++wchar_argv_index) - { - wchar_t *match_argv = this->wchar_argv_[wchar_argv_index]; - // if n'th entries of both argv lists are different - if (ACE_OS::strcmp (this->char_argv_[wchar_argv_index], - ACE_TEXT_ALWAYS_CHAR (match_argv)) != 0) - { - // loop through the wchar argv list entries that are after - // wchar_argv_index - for (int i = wchar_argv_index + 1; i < before_pass_argc_; ++i) - { - if (ACE_OS::strcmp (this->char_argv_[i], - ACE_TEXT_ALWAYS_CHAR (match_argv)) == 0) - { - // swap the pointers in the char argv list - char *temp = this->char_argv_[wchar_argv_index]; - this->char_argv_[wchar_argv_index] = this->char_argv_[i]; - this->char_argv_[i] = temp; - break; - } - } - } - } - - this->cleanup (); -} - -void -ACE_Argv_Type_Converter::align_wchar_with_char (void) -{ - for (int char_argv_index = 0; char_argv_index < saved_argc_; - ++char_argv_index) - { - char* match_argv = this->char_argv_[char_argv_index]; - // if n'th entries of both argv lists are different - if (ACE_OS::strcmp ( - ACE_TEXT_ALWAYS_CHAR (this->wchar_argv_[char_argv_index]), - match_argv) != 0) - { - // loop through the wchar argv list entries that are after - // wchar_argv_index - for (int i = char_argv_index + 1; i < this->before_pass_argc_; ++i) - { - if (ACE_OS::strcmp ( - ACE_TEXT_ALWAYS_CHAR(this->wchar_argv_[i]), - match_argv) == 0) { - // swap the pointers in the char argv list - wchar_t* temp = this->wchar_argv_[char_argv_index]; - this->wchar_argv_[char_argv_index] = this->wchar_argv_[i]; - this->wchar_argv_[i] = temp; - break; - } - } - } - } - - this->cleanup(); -} - -void -ACE_Argv_Type_Converter::cleanup (void) -{ - for (int i = this->saved_argc_; i < this->before_pass_argc_; ++i) - { - // Check whether it's ours to delete. - if (original_type_) - { - ACE_OS::free (this->char_argv_[i]); - this->char_argv_[i] = 0; - } - else - { - ACE_OS::free (this->wchar_argv_[i]); - this->wchar_argv_[i] = 0; - } - } - - this->before_pass_argc_ = this->saved_argc_; - - this->wchar_passed_ = false; - this->char_passed_ = false; -} -#endif // ACE_USES_WCHAR - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Argv_Type_Converter.h b/deps/acelite/ace/Argv_Type_Converter.h deleted file mode 100644 index c2a73f2c1..000000000 --- a/deps/acelite/ace/Argv_Type_Converter.h +++ /dev/null @@ -1,115 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Argv_Type_Converter.h - * - * @author Si Mong Park - */ -//============================================================================= - -#ifndef ACE_ARGV_TYPE_CONVERTER_H -#define ACE_ARGV_TYPE_CONVERTER_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" -#include "ace/OS_Memory.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Argv_Type_Converter - * - * @brief To convert 'char' input/command line parameter to 'wchar_t'. - * - * This class is to convert 'char' type command line parameter to - * wide-character (wchar_t) format and stores the copy of it. - * This is useful for all classes that use 'char**' argv but cannot - * be converted into 'ACE_TCHAR**' version. - * Note that the converted data will be lost upon destruction, so - * classes should use this class as their data member. - */ -class ACE_Export ACE_Argv_Type_Converter -{ -public: - ACE_Argv_Type_Converter (int &argc, char** argv); - -#if defined (ACE_USES_WCHAR) - ACE_Argv_Type_Converter (int &argc, wchar_t** argv); -#endif // ACE_USES_WCHAR - - ~ACE_Argv_Type_Converter (void); - - /// Returns the pointer of converted command line. - ACE_TCHAR** get_TCHAR_argv (void); - - /// Returns the pointer of ASCII (char) command line. - char** get_ASCII_argv (void); - - /// Returns the number of sub parameters (argc). - int& get_argc (void); - -private: - /// Copy Constructor should not be used. - ACE_Argv_Type_Converter (const ACE_Argv_Type_Converter&); - - /// Assignment '=' operator should not be used. - ACE_Argv_Type_Converter operator= (const ACE_Argv_Type_Converter&); - -#if defined (ACE_USES_WCHAR) - - /// Perform common initialization for two Ctor's. - void initialize (void); - - /// Align all entries in the char type argv list with wchar_t type - /// argv list. - void align_char_with_wchar (void); - - /// Align all entries in the wchar_t type argv list with char type - /// argv list. - void align_wchar_with_char (void); - - /// Clean up removed (consumed) argv entries and reset the pass flags. - void cleanup (void); -#endif // ACE_USES_WCHAR - -private: - /// Original number of input parameter, same as 'argc'. - int &saved_argc_; - - /// Data member pointer that contains converted argv in ACE_ANTI_TCHAR. - char** char_argv_; - -#if defined (ACE_USES_WCHAR) - /// Data member pointer that contains converted argv in ACE_TCHAR. - wchar_t** wchar_argv_; - - /// argc value before any argv has been passed. - int before_pass_argc_; - - /// false represents original argv passed in is char, and true - /// represents wchar_t. - bool const original_type_; - - /// true indicates wchar_t type argv has been passed. - bool wchar_passed_; - - /// true indicates char type argv has been passed. - bool char_passed_; -#endif /* ACE_USES_WCHAR */ -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Argv_Type_Converter.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* ACE_ARGV_TYPE_CONVERTER_H */ diff --git a/deps/acelite/ace/Argv_Type_Converter.inl b/deps/acelite/ace/Argv_Type_Converter.inl deleted file mode 100644 index 8c7bc89ca..000000000 --- a/deps/acelite/ace/Argv_Type_Converter.inl +++ /dev/null @@ -1,41 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE ACE_TCHAR** -ACE_Argv_Type_Converter::get_TCHAR_argv (void) -{ -#if defined (ACE_USES_WCHAR) - if (this->char_passed_) - { - this->align_wchar_with_char (); - } - - this->wchar_passed_ = true; - return this->wchar_argv_; -#else - return this->char_argv_; -#endif // ACE_USES_WCHAR -} - -ACE_INLINE char** -ACE_Argv_Type_Converter::get_ASCII_argv (void) -{ -#if defined (ACE_USES_WCHAR) - if (this->wchar_passed_) - { - this->align_char_with_wchar (); - } - - this->char_passed_ = true; -#endif // ACE_USES_WCHAR - - return this->char_argv_; -} - -ACE_INLINE int& -ACE_Argv_Type_Converter::get_argc (void) -{ - return this->saved_argc_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Array_Base.cpp b/deps/acelite/ace/Array_Base.cpp deleted file mode 100644 index 830634f7b..000000000 --- a/deps/acelite/ace/Array_Base.cpp +++ /dev/null @@ -1,233 +0,0 @@ -#ifndef ACE_ARRAY_BASE_CPP -#define ACE_ARRAY_BASE_CPP - -#include "ace/Array_Base.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (__ACE_INLINE__) -#include "ace/Array_Base.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Malloc_Base.h" -#include "ace/os_include/os_errno.h" - -#include - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Dynamically initialize an array. -template -ACE_Array_Base::ACE_Array_Base (typename ACE_Array_Base::size_type size, - ACE_Allocator *alloc) - : max_size_ (size), - cur_size_ (size), - allocator_ (alloc) -{ - if (this->allocator_ == 0) - this->allocator_ = ACE_Allocator::instance (); - - if (size != 0) - { - ACE_ALLOCATOR (this->array_, - (T *) this->allocator_->malloc (size * sizeof (T))); - for (size_type i = 0; i < size; ++i) - new (&array_[i]) T; - } - else - this->array_ = 0; -} - -template -ACE_Array_Base::ACE_Array_Base (typename ACE_Array_Base::size_type size, - const T &default_value, - ACE_Allocator *alloc) - : max_size_ (size), - cur_size_ (size), - allocator_ (alloc) -{ - if (this->allocator_ == 0) - this->allocator_ = ACE_Allocator::instance (); - - if (size != 0) - { - ACE_ALLOCATOR (this->array_, - (T *) this->allocator_->malloc (size * sizeof (T))); - for (size_type i = 0; i < size; ++i) - new (&array_[i]) T (default_value); - } - else - this->array_ = 0; -} - -// The copy constructor (performs initialization). - -template -ACE_Array_Base::ACE_Array_Base (const ACE_Array_Base &s) - : max_size_ (s.size ()), - cur_size_ (s.size ()), - allocator_ (s.allocator_) -{ - if (this->allocator_ == 0) - this->allocator_ = ACE_Allocator::instance (); - - ACE_ALLOCATOR (this->array_, - (T *) this->allocator_->malloc (s.size () * sizeof (T))); - for (size_type i = 0; i < this->size (); ++i) - new (&this->array_[i]) T (s.array_[i]); -} - -// Assignment operator (performs assignment). - -template void -ACE_Array_Base::operator= (const ACE_Array_Base &s) -{ - // Check for "self-assignment". - - if (this != &s) - { - if (this->max_size_ < s.size ()) - { - // Need to reallocate memory. - - // Strongly exception-safe assignment. - // - // Note that we're swapping the allocators here, too. - // Should we? Probably. "*this" should be a duplicate of - // the "right hand side". - ACE_Array_Base tmp (s); - this->swap (tmp); - } - else - { - // Underlying array is large enough. No need to reallocate - // memory. - // - // "*this" still owns the memory for the underlying array. - // Do not swap out the allocator. - // - // @@ Why don't we just drop the explicit destructor and - // placement operator new() calls with a straight - // element-by-element assignment? Is the existing - // approach more efficient? - // -Ossama - - ACE_DES_ARRAY_NOFREE (this->array_, - s.size (), - T); - - this->cur_size_ = s.size (); - - for (size_type i = 0; i < this->size (); ++i) - new (&this->array_[i]) T (s.array_[i]); - } - } -} - -// Set an item in the array at location slot. - -template int -ACE_Array_Base::set (const T &new_item, - typename ACE_Array_Base::size_type slot) -{ - if (this->in_range (slot)) - { - this->array_[slot] = new_item; - return 0; - } - else - return -1; -} - -// Get an item in the array at location slot. - -template int -ACE_Array_Base::get (T &item, - typename ACE_Array_Base::size_type slot) const -{ - if (this->in_range (slot)) - { - // Copies the item. If you don't want to copy, use operator [] - // instead (but then you'll be responsible for range checking). - item = this->array_[slot]; - return 0; - } - else - return -1; -} - -template int -ACE_Array_Base::max_size (typename ACE_Array_Base::size_type new_size) -{ - if (new_size > this->max_size_) - { - T *tmp = 0; - - ACE_ALLOCATOR_RETURN (tmp, - (T *) this->allocator_->malloc (new_size * sizeof (T)), - -1); - for (size_type i = 0; i < this->cur_size_; ++i) - new (&tmp[i]) T (this->array_[i]); - - // Initialize the new portion of the array that exceeds the - // previously allocated section. - for (size_type j = this->cur_size_; j < new_size; ++j) - new (&tmp[j]) T; - - ACE_DES_ARRAY_FREE (this->array_, - this->max_size_, - this->allocator_->free, - T); - this->array_ = tmp; - this->max_size_ = new_size; - this->cur_size_ = new_size; - } - - return 0; -} - -template int -ACE_Array_Base::size (typename ACE_Array_Base::size_type new_size) -{ - int const r = this->max_size (new_size); - - if (r == 0) - this->cur_size_ = new_size; - - return r; -} - -template -void -ACE_Array_Base::swap (ACE_Array_Base & rhs) -{ - std::swap (this->max_size_ , rhs.max_size_); - std::swap (this->cur_size_ , rhs.cur_size_); - std::swap (this->array_ , rhs.array_); - std::swap (this->allocator_, rhs.allocator_); -} - -// **************************************************************** - -template int -ACE_Array_Iterator::next (T *&item) -{ - // ACE_TRACE ("ACE_Array_Iterator::next"); - - if (this->done ()) - { - item = 0; - return 0; - } - else - { - item = &array_[current_]; - return 1; - } -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_ARRAY_BASE_CPP */ diff --git a/deps/acelite/ace/Array_Base.h b/deps/acelite/ace/Array_Base.h deleted file mode 100644 index 15ffe77c3..000000000 --- a/deps/acelite/ace/Array_Base.h +++ /dev/null @@ -1,250 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Array_Base.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_ARRAY_BASE_H -#define ACE_ARRAY_BASE_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Global_Macros.h" -#include "ace/Malloc_Base.h" -#include /* For reverse_iterator adapters */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward declaration. -template class ACE_Array_Iterator; - -/** - * @class ACE_Array_Base - * - * @brief Implement a simple dynamic array - * - * This parametric class implements a simple dynamic array; - * resizing must be controlled by the user. No comparison or find - * operations are implemented. - */ -template -class ACE_Array_Base -{ -public: - // Old/ACE-style traits. - typedef T TYPE; - typedef ACE_Array_Iterator ITERATOR; - - // STL-style typedefs/traits. - typedef T value_type; - typedef value_type * iterator; - typedef value_type const * const_iterator; - typedef value_type & reference; - typedef value_type const & const_reference; - typedef value_type * pointer; - typedef value_type const * const_pointer; - typedef ptrdiff_t difference_type; - typedef ACE_Allocator::size_type size_type; - - ACE_DECLARE_STL_REVERSE_ITERATORS - - /// Dynamically create an uninitialized array. - ACE_Array_Base (size_type size = 0, - ACE_Allocator * the_allocator = 0); - - /// Dynamically initialize the entire array to the @a default_value. - ACE_Array_Base (size_type size, - T const & default_value, - ACE_Allocator * the_allocator = 0); - - /** - * The copy constructor performs initialization by making an exact - * copy of the contents of parameter @a s, i.e., *this == s will - * return true. - */ - ACE_Array_Base (ACE_Array_Base const & s); - - /** - * Assignment operator performs an assignment by making an exact - * copy of the contents of parameter @a s, i.e., *this == s will - * return true. Note that if the of is >= than - * we can copy it without reallocating. However, if - * is < we must delete the , - * reallocate a new , and then copy the contents of . - */ - void operator= (ACE_Array_Base const & s); - - /// Clean up the array (e.g., delete dynamically allocated memory). - ~ACE_Array_Base (void); - - // = Set/get methods. - - /// Set item in the array at location @a slot. Doesn't - /// perform range checking. - T & operator[] (size_type slot); - - /// Get item in the array at location @a slot. Doesn't - /// perform range checking. - T const & operator[] (size_type slot) const; - - /// Set an item in the array at location @a slot. Returns - /// -1 if @a slot is not in range, else returns 0. - int set (T const & new_item, size_type slot); - - /** - * Get an item in the array at location @a slot. Returns -1 if - * @a slot is not in range, else returns 0. Note that this function - * copies the item. If you want to avoid the copy, you can use - * the const operator [], but then you'll be responsible for range checking. - */ - int get (T & item, size_type slot) const; - - /// Returns the of the array. - size_type size (void) const; - - /** - * Changes the size of the array to match @a new_size. - * It copies the old contents into the new array. - * Return -1 on failure. - */ - int size (size_type new_size); - - /// Returns the of the array. - size_type max_size (void) const; - - /** - * Changes the size of the array to match @a new_size. - * It copies the old contents into the new array. - * Return -1 on failure. - * It does not affect new_size - */ - int max_size (size_type new_size); - - /** - * @name Forward Iterator Accessors - * - * Forward iterator accessors. - */ - //@{ - iterator begin (void); - iterator end (void); - const_iterator begin (void) const; - const_iterator end (void) const; - //@} - - /** - * @name Reverse Iterator Accessors - * - * Reverse iterator accessors. - */ - //@{ - reverse_iterator rbegin (void); - reverse_iterator rend (void); - const_reverse_iterator rbegin (void) const; - const_reverse_iterator rend (void) const; - //@} - - /// Swap the contents of this array with the given @a array in - /// an exception-safe manner. - void swap (ACE_Array_Base & array); - -protected: - - /// Returns 1 if @a slot is within range, i.e., 0 >= @a slot < - /// @c cur_size_, else returns 0. - bool in_range (size_type slot) const; - - /// Maximum size of the array, i.e., the total number of @c T elements - /// in @c array_. - size_type max_size_; - - /** - * Current size of the array. This starts out being == to - * . However, if we are assigned a smaller array, then - * will become less than . The purpose of - * keeping track of both sizes is to avoid reallocating memory if we - * don't have to. - */ - size_type cur_size_; - - /// Pointer to the array's storage buffer. - value_type * array_; - - /// Allocation strategy of the ACE_Array_Base. - ACE_Allocator * allocator_; - - friend class ACE_Array_Iterator; -}; - -// **************************************************************** - -/** - * @class ACE_Array_Iterator - * - * @brief Implement an iterator over an ACE_Array. - * - * This iterator is safe in the face of array element deletions. - * But it is NOT safe if the array is resized (via the ACE_Array - * assignment operator) during iteration. That would be very - * odd, and dangerous. - */ -template -class ACE_Array_Iterator -{ -public: - ACE_Array_Iterator (ACE_Array_Base &); - - // = Iteration methods. - - /// Pass back the @a next_item that hasn't been seen in the Array. - /// Returns 0 when all items have been seen, else 1. - int next (T *&next_item); - - /// Move forward by one element in the Array. Returns 0 when all the - /// items in the Array have been seen, else 1. - int advance (void); - - /// Returns 1 when all items have been seen, else 0. - int done (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Pointer to the current item in the iteration. - size_t current_; - - /// Pointer to the Array we're iterating over. - ACE_Array_Base &array_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Array_Base.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Array_Base.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Array_Base.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_ARRAY_BASE_H */ diff --git a/deps/acelite/ace/Array_Base.inl b/deps/acelite/ace/Array_Base.inl deleted file mode 100644 index ccd367f2d..000000000 --- a/deps/acelite/ace/Array_Base.inl +++ /dev/null @@ -1,143 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Clean up the array (e.g., delete dynamically allocated memory). -template ACE_INLINE -ACE_Array_Base::~ACE_Array_Base (void) -{ - ACE_DES_ARRAY_FREE (this->array_, - this->max_size_, - this->allocator_->free, - T); -} - -template -ACE_INLINE typename ACE_Array_Base::iterator -ACE_Array_Base::begin (void) -{ - return this->array_; -} - -template -ACE_INLINE typename ACE_Array_Base::iterator -ACE_Array_Base::end (void) -{ - return this->array_ + this->cur_size_; -} - -template -ACE_INLINE typename ACE_Array_Base::const_iterator -ACE_Array_Base::begin (void) const -{ - return this->array_; -} - -template -ACE_INLINE typename ACE_Array_Base::const_iterator -ACE_Array_Base::end (void) const -{ - return this->array_ + this->cur_size_; -} - -template -ACE_INLINE typename ACE_Array_Base::reverse_iterator -ACE_Array_Base::rbegin (void) -{ - return reverse_iterator (this->end ()); -} - -template -ACE_INLINE typename ACE_Array_Base::reverse_iterator -ACE_Array_Base::rend (void) -{ - return reverse_iterator (this->begin ()); -} - -template -ACE_INLINE typename ACE_Array_Base::const_reverse_iterator -ACE_Array_Base::rbegin (void) const -{ - return const_reverse_iterator (this->end ()); -} - -template -ACE_INLINE typename ACE_Array_Base::const_reverse_iterator -ACE_Array_Base::rend (void) const -{ - return const_reverse_iterator (this->begin ()); -} - -template ACE_INLINE typename ACE_Array_Base::size_type -ACE_Array_Base::size (void) const -{ - return this->cur_size_; -} - -template ACE_INLINE typename ACE_Array_Base::size_type -ACE_Array_Base::max_size (void) const -{ - return this->max_size_; -} - -template ACE_INLINE bool -ACE_Array_Base::in_range (typename ACE_Array_Base::size_type index) const -{ - return index < this->cur_size_; -} - -template ACE_INLINE T & -ACE_Array_Base::operator[] (typename ACE_Array_Base::size_type index) -{ - return this->array_[index]; -} - -template ACE_INLINE const T & -ACE_Array_Base::operator[] (typename ACE_Array_Base::size_type index) const -{ - return this->array_[index]; -} - -// **************************************************************** - -template ACE_INLINE void -ACE_Array_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - // ACE_TRACE ("ACE_Array_Iterator::dump"); -#endif /* ACE_HAS_DUMP */ -} - -template ACE_INLINE -ACE_Array_Iterator::ACE_Array_Iterator (ACE_Array_Base &a) - : current_ (0), - array_ (a) -{ - // ACE_TRACE ("ACE_Array_Iterator::ACE_Array_Iterator"); -} - -template ACE_INLINE int -ACE_Array_Iterator::advance (void) -{ - // ACE_TRACE ("ACE_Array_Iterator::advance"); - - if (this->current_ < array_.size ()) - { - ++this->current_; - return 1; - } - else - { - // Already finished iterating. - return 0; - } -} - -template ACE_INLINE int -ACE_Array_Iterator::done (void) const -{ - ACE_TRACE ("ACE_Array_Iterator::done"); - - return this->current_ >= array_.size (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Array_Map.cpp b/deps/acelite/ace/Array_Map.cpp deleted file mode 100644 index 4917c51e4..000000000 --- a/deps/acelite/ace/Array_Map.cpp +++ /dev/null @@ -1,259 +0,0 @@ -#ifndef ACE_ARRAY_MAP_CPP -#define ACE_ARRAY_MAP_CPP - -#include "ace/Array_Map.h" - -#ifndef __ACE_INLINE__ -# include "ace/Array_Map.inl" -#endif /* !__ACE_INLINE__ */ - -#include "ace/checked_iterator.h" - -#include - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -template -ACE_Array_Map::ACE_Array_Map (InputIterator f, - InputIterator l) - : size_ (l - f) - , capacity_ (size_) - , nodes_ (size_ == 0 ? 0 : this->alloc_.allocate (size_)) -{ - (void) std::uninitialized_copy (f, - l, - ACE_make_checked_array_iterator (this->begin (), - this->size_)); -} - -template -ACE_Array_Map::ACE_Array_Map ( - ACE_Array_Map const & map) - : size_ (map.size_) - , capacity_ (map.size_) - , nodes_ (size_ == 0 ? 0 : this->alloc_.allocate (size_)) -{ - (void) std::uninitialized_copy (map.begin (), - map.end (), - ACE_make_checked_array_iterator (this->begin (), - this->size_)); -} - -template -ACE_Array_Map::~ACE_Array_Map (void) -{ - for (size_t idx = 0; idx != capacity_; ++idx) - { -#if defined (ACE_HAS_BCC32) - using std::pair; - (nodes_ + idx)->~pair(); -#else - (nodes_ + idx)->~value_type(); -#endif - - } - - alloc_.deallocate(this->nodes_, capacity_); -} - -template -void -ACE_Array_Map::swap ( - ACE_Array_Map & map) -{ - std::swap (this->size_, map.size_); - std::swap (this->capacity_, map.capacity_); - std::swap (this->nodes_, map.nodes_); -} - -template -std::pair::iterator, bool> -ACE_Array_Map::insert ( - typename ACE_Array_Map::value_type const & x) -{ - // Linear insertion due to linear duplicate key search. - - bool inserted = false; - iterator i = this->find (x.first); - - if (i == this->end ()) - { - // Add the element to the array. - - size_type const old_size = this->size (); - this->grow (1); // Increase size by at least one. - - i = this->begin () + old_size; - *i = x; - - ++this->size_; - - inserted = true; - } - - return std::make_pair (i, inserted); -} - -template -template -void -ACE_Array_Map::insert (InputIterator f, InputIterator l) -{ - this->grow (l - f); // Preallocate storage. - - for (InputIterator i = f; i != l; ++i) - { - (void) this->insert (*i); - } -} - -template -void -ACE_Array_Map::erase ( - typename ACE_Array_Map::iterator pos) -{ - iterator const first = this->begin (); - iterator const last = this->end (); - - if (pos >= first && pos < last) - { - if (pos != last - 1) - { - // Relocate the tail element to the location of the erased - // element to prevent introduction of "holes" in the - // underlying array. - *pos = *(last - 1); - } - - // Explicitly destroy the tail element by assigning a default - // constructed instance to it. Note that this also works for - // the case of a map of size 1. - *(last - 1) = value_type (); - - --this->size_; - } -} - -template -typename ACE_Array_Map::size_type -ACE_Array_Map::erase ( - typename ACE_Array_Map::key_type const & k) -{ - iterator pos = this->find (k); - - size_type const old_size = this->size_; - - this->erase (pos); - - return old_size - this->size_; -} - -template -void -ACE_Array_Map::erase ( - typename ACE_Array_Map::iterator first, - typename ACE_Array_Map::iterator last) -{ - if (this->begin () <= first && first < last && last < this->end ()) - for (iterator i = first; i != last; ++i) - this->erase (i); -} - -template -void -ACE_Array_Map::clear (void) -{ - this->size_ = 0; // No need to deallocate array nor destroy elements. -} - -template -typename ACE_Array_Map::iterator -ACE_Array_Map::find ( - typename ACE_Array_Map::key_type const & k) -{ - iterator const the_end = this->end (); - - EqualTo eq; - - for (iterator i = this->begin (); i != the_end; ++i) - if (eq (k, i->first)) - return i; - - return this->end (); -} - -template -typename ACE_Array_Map::const_iterator -ACE_Array_Map::find ( - typename ACE_Array_Map::key_type const & k) const -{ - const_iterator const the_end = this->end (); - - EqualTo eq; - - for (const_iterator i = this->begin (); i != the_end; ++i) - if (eq (k, i->first)) - return i; - - return this->end (); -} - -template -void -ACE_Array_Map::grow ( - typename ACE_Array_Map::size_type s) -{ - if (this->size () + s > this->capacity_) - { - // This implementation focuses more on static footprint than - // speed. - - // Strongly exception safe. - - ACE_Array_Map temp (this->size () + s); - - std::copy (this->begin (), - this->end (), - ACE_make_checked_array_iterator (temp.begin (), - temp.capacity_)); - - size_type const n = this->size (); // Do not swap out the size - // since we bypassed the - // temporary map's element - // counting code. - this->swap (temp); - - this->size_ = n; - } -} - -// --------------------------------------------------------------- - -template -bool -operator== (ACE_Array_Map const & lhs, - ACE_Array_Map const & rhs) -{ - // Do not include Array_Map capacity in comparison. It isn't useful - // in this case. - - return (lhs.size () == rhs.size () - && std::equal (lhs.begin (), - lhs.end (), - ACE_make_checked_array_iterator (rhs.begin (), - rhs.size ()))); -} - -template -bool -operator< (ACE_Array_Map const & lhs, - ACE_Array_Map const & rhs) -{ - return std::lexicographical_compare (lhs.begin (), lhs.end (), - rhs.begin (), rhs.end ()); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_ARRAY_MAP_CPP */ diff --git a/deps/acelite/ace/Array_Map.h b/deps/acelite/ace/Array_Map.h deleted file mode 100644 index 5fd040069..000000000 --- a/deps/acelite/ace/Array_Map.h +++ /dev/null @@ -1,300 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Array_Map.h - * - * Light weight array-based map with fast iteration but linear - * (i.e. O(n)) search times. STL-style interface is exposed. - * - * @note This class requires the STL generic algorithms and - * reverse_iterator adapter. - * - * @author Ossama Othman - */ -//============================================================================= - - -#ifndef ACE_ARRAY_MAP_H -#define ACE_ARRAY_MAP_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-lite.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include -#include -#include -#include - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -#if defined __SUNPRO_CC && !defined _RWSTD_ALLOCATOR -# define ACE_ARRAY_MAP_DEFAULT_ALLOCATOR(K, V) std::allocator_interface< \ - std::allocator, \ - std::pair > -#else -# define ACE_ARRAY_MAP_DEFAULT_ALLOCATOR(K, V) std::allocator > -#endif - -/** - * @class ACE_Array_Map - * - * @brief Light weight array-based map with fast iteration, but linear - * (i.e. O(n)) search times. - * - * Map implementation that focuses on small footprint and fast - * iteration. Search times are, however, linear (O(n)) meaning that - * this map isn't suitable for large data sets that will be searched - * in performance critical areas of code. Iteration over large data - * sets, however, is faster than linked list-based maps, for example, - * since spatial locality is maximized through the use of contiguous - * arrays as the underlying storage. - * @par - * An @c ACE_Array_Map is a unique associative container, meaning that - * duplicate values may not be added to the map. It is also pair - * associative (value_type is a std::pair<>). It is not a sorted - * container. - * @par - * An STL @c std::map -like interface is exposed by this class - * portability. Furthermore, this map's iterators are compatible with - * STL algorithms. - * @par - * Requirements and Performance Characteristics - * - Internal Structure - * Array - * - Duplicates allowed? - * No - * - Random access allowed? - * Yes - * - Search speed - * O(n) - * - Insert/replace speed - * O(n), can be longer if the map has to resize - * - Iterator still valid after change to container? - * No - * - Frees memory for removed elements? - * Yes - * - Items inserted by - * Value - * - Requirements for key type - * -# Default constructor - * -# Copy constructor - * -# operator= - * -# operator== - * - Requirements for object type - * -# Default constructor - * -# Copy constructor - * -# operator= - */ -template, - class Alloc = ACE_ARRAY_MAP_DEFAULT_ALLOCATOR (Key, Value) > -class ACE_Array_Map -{ -public: - // STL-style typedefs/traits. - typedef Key key_type; - typedef Value mapped_type; - typedef Value data_type; - typedef std::pair value_type; - typedef Alloc allocator_type; - typedef value_type & reference; - typedef value_type const & const_reference; - typedef value_type * pointer; - typedef value_type const * const_pointer; - typedef value_type * iterator; - typedef value_type const * const_iterator; - typedef ptrdiff_t difference_type; - typedef size_t size_type; - ACE_DECLARE_STL_REVERSE_ITERATORS - - /// Default Constructor. - /** - * Create an empty map with a preallocated buffer of size @a s. - */ - ACE_Array_Map (size_type s = 0); - - template - ACE_Array_Map (InputIterator f, InputIterator l); - - ACE_Array_Map (ACE_Array_Map const & map); - ACE_Array_Map & operator= (ACE_Array_Map const & map); - - /// Destructor. - ~ACE_Array_Map (void); - - /** - * @name Forward Iterator Accessors - * - * Forward iterator accessors. - */ - //@{ - iterator begin (void); - iterator end (void); - const_iterator begin (void) const; - const_iterator end (void) const; - //@} - - /** - * @name Reverse Iterator Accessors - * - * Reverse iterator accessors. - */ - //@{ - reverse_iterator rbegin (void); - reverse_iterator rend (void); - const_reverse_iterator rbegin (void) const; - const_reverse_iterator rend (void) const; - //@} - - /// Return current size of map. - /** - * @return The number of elements in the map. - */ - size_type size (void) const; - - /// Maximum number of elements the map can hold. - size_type max_size (void) const; - - /// Return @c true if the map is empty, else @c false. - bool is_empty (void) const; // ACE style - - /** - * Return @c true if the map is empty, else @c false. We recommend - * using @c is_empty() instead since it's more consistent with the - * ACE container naming conventions. - */ - bool empty (void) const; // STL style - - /// Swap the contents of this map with the given @a map in an - /// exception-safe manner. - void swap (ACE_Array_Map & map); - - /// Insert the value @a x into the map. - /** - * STL-style map insertion method. - * - * @param x @c std::pair containing key and datum. - * - * @return @c std::pair::second will be @c false if the map already - * contains a value with the same key as @a x. - */ - std::pair insert (value_type const & x); - - /// Insert range of elements into map. - template - void insert (InputIterator f, InputIterator l); - - /// Remove element at position @a pos from the map. - void erase (iterator pos); - - /// Remove element corresponding to key @a k from the map. - /** - * @return Number of elements that were erased. - */ - size_type erase (key_type const & k); - - /// Remove range of elements [@a first, @a last) from the map. - /** - * @note [@a first, @a last) must be valid range within the map. - */ - void erase (iterator first, iterator last); - - /// Clear contents of map. - /** - * @note This a constant time (O(1)) operation. - */ - void clear (void); - - /** - * @name Search Operations - * - * Search the map for data corresponding to key @a k. - */ - //@{ - /** - * @return @c end() if data corresponding to key @a k is not in the - * map. - */ - iterator find (key_type const & k); - - /** - * @return @c end() if data corresponding to key @a k is not in the - * map. - */ - const_iterator find (key_type const & k) const; - //@} - - /// Count the number of elements corresponding to key @a k. - /** - * @return In the case of this map, the count will always be one if - * such exists in the map. - */ - size_type count (key_type const & k); - - /// Convenience array index operator. - /** - * Array index operator that allows insertion and retrieval of - * elements using an array index syntax, such as: - * @par - * map["Foo"] = 12; - */ - mapped_type & operator[] (key_type const & k); - - allocator_type get_allocator() const { return alloc_; } - -private: - /// Increase size of underlying buffer by @a s. - void grow (size_type s); - - /// The allocator. - allocator_type alloc_; - - /// Number of elements in the map. - size_type size_; - - /// Current size of underlying array. - /** - * @note @c capacity_ is always greater than or equal to @c size_; - */ - size_type capacity_; - - /// Underlying array containing keys and data. - value_type * nodes_; -}; - -// -------------------------------------------------------------- - -/// @c ACE_Array_Map equality operator. -template -bool operator== (ACE_Array_Map const & lhs, - ACE_Array_Map const & rhs); - -/// @c ACE_Array_Map lexicographical comparison operator. -template -bool operator< (ACE_Array_Map const & lhs, - ACE_Array_Map const & rhs); - -// -------------------------------------------------------------- - -ACE_END_VERSIONED_NAMESPACE_DECL - -#ifdef __ACE_INLINE__ -# include "ace/Array_Map.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -# include "ace/Array_Map.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Array_Map.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_ARRAY_MAP_H */ diff --git a/deps/acelite/ace/Array_Map.inl b/deps/acelite/ace/Array_Map.inl deleted file mode 100644 index 32e7848c0..000000000 --- a/deps/acelite/ace/Array_Map.inl +++ /dev/null @@ -1,131 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_INLINE -ACE_Array_Map::ACE_Array_Map ( - typename ACE_Array_Map::size_type s) - : size_ (0) - , capacity_ (s) - , nodes_ (s == 0 ? 0 : this->alloc_.allocate (s)) -{ - std::uninitialized_fill_n (this->nodes_, s, value_type ()); -} - -template -ACE_INLINE ACE_Array_Map & -ACE_Array_Map::operator= ( - ACE_Array_Map const & map) -{ - // Strongly exception-safe assignment. - - ACE_Array_Map temp (map); - this->swap (temp); - return *this; -} - -template -ACE_INLINE typename ACE_Array_Map::iterator -ACE_Array_Map::begin (void) -{ - return this->nodes_; -} - -template -ACE_INLINE typename ACE_Array_Map::iterator -ACE_Array_Map::end (void) -{ - return this->nodes_ + this->size_; -} - -template -ACE_INLINE typename ACE_Array_Map::const_iterator -ACE_Array_Map::begin (void) const -{ - return this->nodes_; -} - -template -ACE_INLINE typename ACE_Array_Map::const_iterator -ACE_Array_Map::end (void) const -{ - return this->nodes_ + this->size_; -} - -template -ACE_INLINE typename ACE_Array_Map::reverse_iterator -ACE_Array_Map::rbegin (void) -{ - return reverse_iterator (this->end ()); -} - -template -ACE_INLINE typename ACE_Array_Map::reverse_iterator -ACE_Array_Map::rend (void) -{ - return reverse_iterator (this->begin ()); -} - -template -ACE_INLINE typename ACE_Array_Map::const_reverse_iterator -ACE_Array_Map::rbegin (void) const -{ - return const_reverse_iterator (this->end ()); -} - -template -ACE_INLINE typename ACE_Array_Map::const_reverse_iterator -ACE_Array_Map::rend (void) const -{ - return const_reverse_iterator (this->begin ()); -} - -template -ACE_INLINE typename ACE_Array_Map::size_type -ACE_Array_Map::size (void) const -{ - return this->size_; -} - -template -ACE_INLINE typename ACE_Array_Map::size_type -ACE_Array_Map::max_size (void) const -{ - return size_type (-1) / sizeof (value_type); -} - -template -ACE_INLINE bool -ACE_Array_Map::is_empty (void) const -{ - return this->size_ == 0; -} - -// The following method is deprecated. - -template -ACE_INLINE bool -ACE_Array_Map::empty (void) const -{ - return this->is_empty (); -} - -template -ACE_INLINE typename ACE_Array_Map::size_type -ACE_Array_Map::count ( - typename ACE_Array_Map::key_type const & k) -{ - return - (this->find (k) == this->end () ? 0 : 1); // Only one datum per key. -} - -template -ACE_INLINE typename ACE_Array_Map::mapped_type & -ACE_Array_Map::operator[] ( - typename ACE_Array_Map::key_type const & k) -{ - iterator i = (this->insert (value_type (k, mapped_type ()))).first; - return (*i).second; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Assert.cpp b/deps/acelite/ace/Assert.cpp deleted file mode 100644 index 45524c643..000000000 --- a/deps/acelite/ace/Assert.cpp +++ /dev/null @@ -1,25 +0,0 @@ -#include "ace/Assert.h" -#include "ace/Log_Category.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// The following ASSERT macro is courtesy of Alexandre Karev -// . -void -__ace_assert(const char *file, int line, const ACE_TCHAR *expression) -{ - int error = ACE_Log_Msg::last_error_adapter (); - ACE_Log_Msg *log = ACE_Log_Msg::instance (); - - log->set (file, line, -1, error, log->restart (), - log->msg_ostream (), log->msg_callback ()); - -#ifdef ACE_LACKS_VA_FUNCTIONS -#define LOG_ARGS -#else -#define LOG_ARGS(X) X -#endif - log->log LOG_ARGS ((LM_ERROR, ACE_TEXT ("ACE_ASSERT: file %N, line %l assertion failed for '%s'.%a\n"), expression, -1)); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Assert.h b/deps/acelite/ace/Assert.h deleted file mode 100644 index 33c5a4c25..000000000 --- a/deps/acelite/ace/Assert.h +++ /dev/null @@ -1,38 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Assert.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_ASSERT_H -#define ACE_ASSERT_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#include /**/ "ace/config-all.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -ACE_Export void __ace_assert(const char *file, int line, const ACE_TCHAR *expression); -ACE_END_VERSIONED_NAMESPACE_DECL - -#define ACE_TEST_ASSERT(X) \ - ((X) \ - ? static_cast(0) \ - : ACE_VERSIONED_NAMESPACE_NAME::__ace_assert(__FILE__, __LINE__, ACE_TEXT_CHAR_TO_TCHAR (#X))) - -#if defined (ACE_NDEBUG) -#define ACE_ASSERT(x) \ - (static_cast(0)) -#else -#define ACE_ASSERT(X) ACE_TEST_ASSERT(X) -#endif /* ACE_NDEBUG */ - -#include /**/ "ace/post.h" - -#endif /* ACE_ASSERT */ diff --git a/deps/acelite/ace/Asynch_Acceptor.cpp b/deps/acelite/ace/Asynch_Acceptor.cpp deleted file mode 100644 index c518c3a62..000000000 --- a/deps/acelite/ace/Asynch_Acceptor.cpp +++ /dev/null @@ -1,506 +0,0 @@ -/* -*- C++ -*- */ -#ifndef ACE_ASYNCH_ACCEPTOR_C -#define ACE_ASYNCH_ACCEPTOR_C - -#include "ace/Asynch_Acceptor.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS) -// This only works on platforms that support async i/o. - -#include "ace/OS_Errno.h" -#include "ace/OS_Memory.h" -#include "ace/OS_NS_sys_socket.h" -#include "ace/Log_Category.h" -#include "ace/Message_Block.h" -#include "ace/INET_Addr.h" -#include "ace/SOCK_Stream.h" -#include "ace/Sock_Connect.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Asynch_Acceptor::ACE_Asynch_Acceptor (void) - : listen_handle_ (ACE_INVALID_HANDLE), - pass_addresses_ (false), - validate_new_connection_ (false), - reissue_accept_ (1), - bytes_to_read_ (0), - addr_family_ (0) -{ -} - -template -ACE_Asynch_Acceptor::~ACE_Asynch_Acceptor (void) -{ - // Close down the listen socket - if (this->listen_handle_ != ACE_INVALID_HANDLE) - { - ACE_OS::closesocket (this->listen_handle_); - this->listen_handle_ = ACE_INVALID_HANDLE; - } -} - -template int -ACE_Asynch_Acceptor::open (const ACE_INET_Addr &address, - size_t bytes_to_read, - bool pass_addresses, - int backlog, - int reuse_addr, - ACE_Proactor *proactor, - bool validate_new_connection, - int reissue_accept, - int number_of_initial_accepts) -{ - ACE_TRACE ("ACE_Asynch_Acceptor<>::open"); - - this->proactor (proactor); - this->pass_addresses_ = pass_addresses; - this->bytes_to_read_ = bytes_to_read; - this->validate_new_connection_ = validate_new_connection; - this->reissue_accept_ = reissue_accept; - this->addr_family_ = address.get_type (); - - // Create the listener socket - this->listen_handle_ = ACE_OS::socket (address.get_type (), SOCK_STREAM, 0); - if (this->listen_handle_ == ACE_INVALID_HANDLE) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_OS::socket")), - -1); - // Initialize the ACE_Asynch_Accept - if (this->asynch_accept_.open (*this, - this->listen_handle_, - 0, - this->proactor ()) == -1) - { - ACE_Errno_Guard g (errno); - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Asynch_Accept::open"))); - ACE_OS::closesocket (this->listen_handle_); - this->listen_handle_ = ACE_INVALID_HANDLE; - return -1; - } - - if (reuse_addr) - { - // Reuse the address - int one = 1; - if (ACE_OS::setsockopt (this->listen_handle_, - SOL_SOCKET, - SO_REUSEADDR, - (const char*) &one, - sizeof one) == -1) - { - ACE_Errno_Guard g (errno); - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_OS::setsockopt"))); - ACE_OS::closesocket (this->listen_handle_); - this->listen_handle_ = ACE_INVALID_HANDLE; - return -1; - } - } - - // If port is not specified, bind to any port. - static ACE_INET_Addr sa (ACE_sap_any_cast (const ACE_INET_Addr &)); - - if (address == sa && - ACE::bind_port (this->listen_handle_, - INADDR_ANY, - address.get_type()) == -1) - { - ACE_Errno_Guard g (errno); - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::bind_port"))); - ACE_OS::closesocket (this->listen_handle_); - this->listen_handle_ = ACE_INVALID_HANDLE; - return -1; - } - - // Bind to the specified port. - if (ACE_OS::bind (this->listen_handle_, - reinterpret_cast (address.get_addr ()), - address.get_size ()) == -1) - { - ACE_Errno_Guard g (errno); - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_OS::bind"))); - ACE_OS::closesocket (this->listen_handle_); - this->listen_handle_ = ACE_INVALID_HANDLE; - return -1; - } - - // Start listening. - if (ACE_OS::listen (this->listen_handle_, backlog) == -1) - { - ACE_Errno_Guard g (errno); - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_OS::listen"))); - ACE_OS::closesocket (this->listen_handle_); - this->listen_handle_ = ACE_INVALID_HANDLE; - return -1; - } - - // For the number of . - if (number_of_initial_accepts == -1) - number_of_initial_accepts = backlog; - - for (int i = 0; i < number_of_initial_accepts; i++) - { - // Initiate accepts. - if (this->accept (bytes_to_read) == -1) - { - ACE_Errno_Guard g (errno); - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Asynch_Acceptor::accept"))); - ACE_OS::closesocket (this->listen_handle_); - this->listen_handle_ = ACE_INVALID_HANDLE; - return -1; - } - } - - return 0; -} - -template int -ACE_Asynch_Acceptor::set_handle (ACE_HANDLE listen_handle) -{ - ACE_TRACE ("ACE_Asynch_Acceptor<>::set_handle"); - - // Take ownership of the - this->listen_handle_ = listen_handle; - - // Reinitialize the ACE_Asynch_Accept - if (this->asynch_accept_.open (*this, - this->listen_handle_, - 0, - this->proactor ()) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Asynch_Accept::open")), - -1); - return 0; -} - -template ACE_HANDLE -ACE_Asynch_Acceptor::get_handle (void) const -{ - return this->listen_handle_; -} - -template int -ACE_Asynch_Acceptor::accept (size_t bytes_to_read, const void *act) -{ - ACE_TRACE ("ACE_Asynch_Acceptor<>::accept"); - - ACE_Message_Block *message_block = 0; - // The space_needed calculation is drive by needs of Windows. POSIX doesn't - // need to extra 16 bytes, but it doesn't hurt. - size_t space_needed = sizeof (sockaddr_in) + 16; -#if defined (ACE_HAS_IPV6) - if (PF_INET6 == this->addr_family_) - space_needed = sizeof (sockaddr_in6) + 16; -#endif /* ACE_HAS_IPV6 */ - space_needed = (2 * space_needed) + bytes_to_read; - - // Create a new message block big enough for the addresses and data - ACE_NEW_RETURN (message_block, - ACE_Message_Block (space_needed), - -1); - - // Initiate asynchronous accepts - if (this->asynch_accept_.accept (*message_block, - bytes_to_read, - ACE_INVALID_HANDLE, - act, - 0, - ACE_SIGRTMIN, - this->addr_family_) == -1) - { - // Cleanup on error - message_block->release (); - return -1; - } - return 0; -} - -template void -ACE_Asynch_Acceptor::handle_accept (const ACE_Asynch_Accept::Result &result) -{ - ACE_TRACE ("ACE_Asynch_Acceptor<>::handle_accept"); - - // Variable for error tracking - int error = 0; - - // If the asynchronous accept fails. - if (!result.success () || result.accept_handle () == ACE_INVALID_HANDLE) - { - error = 1; - } - -#if defined (ACE_WIN32) - // In order to use accept handle with other Window Sockets 1.1 - // functions, we call the setsockopt function with the - // SO_UPDATE_ACCEPT_CONTEXT option. This option initializes the - // socket so that other Windows Sockets routines to access the - // socket correctly. - if (!error && - ACE_OS::setsockopt (result.accept_handle (), - SOL_SOCKET, - SO_UPDATE_ACCEPT_CONTEXT, - (char *) &this->listen_handle_, - sizeof (this->listen_handle_)) == -1) - { - error = 1; - } -#endif /* ACE_WIN32 */ - - // Parse address. - ACE_INET_Addr local_address; - ACE_INET_Addr remote_address; - if (!error && - (this->validate_new_connection_ || this->pass_addresses_)) - // Parse the addresses. - this->parse_address (result, - remote_address, - local_address); - - // Validate remote address - if (!error && - this->validate_new_connection_ && - (this->validate_connection (result, remote_address, local_address) == -1)) - { - error = 1; - } - - HANDLER *new_handler = 0; - if (!error) - { - // The Template method - new_handler = this->make_handler (); - if (new_handler == 0) - { - error = 1; - } - } - - // If no errors - if (!error) - { - // Update the Proactor unless make_handler() or constructed handler - // set up its own. - if (new_handler->proactor () == 0) - new_handler->proactor (this->proactor ()); - - // Pass the addresses - if (this->pass_addresses_) - new_handler->addresses (remote_address, - local_address); - - // Pass the ACT - if (result.act () != 0) - new_handler->act (result.act ()); - - // Set up the handler's new handle value - new_handler->handle (result.accept_handle ()); - - // Initiate the handler - new_handler->open (result.accept_handle (), - result.message_block ()); - } - - // On failure, no choice but to close the socket - if (error && - result.accept_handle() != ACE_INVALID_HANDLE ) - ACE_OS::closesocket (result.accept_handle ()); - - // Delete the dynamically allocated message_block - result.message_block ().release (); - - // Start off another asynchronous accept to keep the backlog going, - // unless we closed the listen socket already (from the destructor), - // or this callback is the result of a canceled/aborted accept. - if (this->should_reissue_accept () && - this->listen_handle_ != ACE_INVALID_HANDLE -#if defined (ACE_WIN32) - && result.error () != ERROR_OPERATION_ABORTED -#else - && result.error () != ECANCELED -#endif - ) - this->accept (this->bytes_to_read_, result.act ()); -} - -template int -ACE_Asynch_Acceptor::validate_connection - (const ACE_Asynch_Accept::Result& /* result */, - const ACE_INET_Addr& /* remote */, - const ACE_INET_Addr& /* local */) -{ - // Default implementation always validates the remote address. - return 0; -} - -template int -ACE_Asynch_Acceptor::cancel (void) -{ - ACE_TRACE ("ACE_Asynch_Acceptor<>::cancel"); - - // All I/O operations that are canceled will complete with the error - // ERROR_OPERATION_ABORTED. All completion notifications for the I/O - // operations will occur normally. -#if defined (ACE_HAS_WIN32_OVERLAPPED_IO) - return (int) ::CancelIo (this->listen_handle_); -#else - // Supported now - return this->asynch_accept_.cancel(); -#endif /* defined (ACE_HAS_WIN32_OVERLAPPED_IO) */ -} - -template void -ACE_Asynch_Acceptor::parse_address (const - ACE_Asynch_Accept::Result &result, - ACE_INET_Addr &remote_address, - ACE_INET_Addr &local_address) -{ - ACE_TRACE ("ACE_Asynch_Acceptor<>::parse_address"); - -#if defined (ACE_HAS_AIO_CALLS) - - // Use an ACE_SOCK to get the addresses - it knows how to deal with - // ACE_INET_Addr objects and get IPv4/v6 addresses. - ACE_SOCK_Stream str (result.accept_handle ()); - str.get_local_addr (local_address); - str.get_remote_addr (remote_address); - -#elif defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) - - ACE_Message_Block &message_block = result.message_block (); - - sockaddr *local_addr = 0; - sockaddr *remote_addr = 0; - int local_size = 0; - int remote_size = 0; - // This matches setup in accept(). - size_t addr_size = sizeof (sockaddr_in) + 16; -#if defined (ACE_HAS_IPV6) - if (this->addr_family_ == PF_INET6) - addr_size = sizeof (sockaddr_in6) + 16; -#endif /* ACE_HAS_IPV6 */ - - ::GetAcceptExSockaddrs (message_block.rd_ptr (), - static_cast (this->bytes_to_read_), - static_cast (addr_size), - static_cast (addr_size), - &local_addr, - &local_size, - &remote_addr, - &remote_size); - - local_address.set (reinterpret_cast (local_addr), - local_size); - remote_address.set (reinterpret_cast (remote_addr), - remote_size); -#else - // just in case - errno = ENOTSUP; -#endif /* defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) */ - return; -} - -template ACE_HANDLE -ACE_Asynch_Acceptor::handle (void) const -{ - return this->listen_handle_; -} - -template void -ACE_Asynch_Acceptor::handle (ACE_HANDLE h) -{ - ACE_Handler::handle (h); -} - -template ACE_Asynch_Accept & -ACE_Asynch_Acceptor::asynch_accept (void) -{ - return this->asynch_accept_; -} - -template HANDLER * -ACE_Asynch_Acceptor::make_handler (void) -{ - // Default behavior - HANDLER *handler = 0; - ACE_NEW_RETURN (handler, - HANDLER, - 0); - return handler; -} - -template bool -ACE_Asynch_Acceptor::pass_addresses (void) const -{ - return this->pass_addresses_; -} - -template void -ACE_Asynch_Acceptor::pass_addresses (bool new_value) -{ - this->pass_addresses_ = new_value; -} - -template bool -ACE_Asynch_Acceptor::validate_new_connection (void) const -{ - return this->validate_new_connection_; -} - -template void -ACE_Asynch_Acceptor::validate_new_connection (bool new_value) -{ - this->validate_new_connection_ = new_value; -} - -template int -ACE_Asynch_Acceptor::reissue_accept (void) const -{ - return this->reissue_accept_; -} - -template void -ACE_Asynch_Acceptor::reissue_accept (int new_value) -{ - this->reissue_accept_ = new_value; -} - -template size_t -ACE_Asynch_Acceptor::bytes_to_read (void) const -{ - return this->bytes_to_read_; -} - -template void -ACE_Asynch_Acceptor::bytes_to_read (size_t new_value) -{ - this->bytes_to_read_ = new_value; -} - -template int -ACE_Asynch_Acceptor::should_reissue_accept (void) -{ - return this->reissue_accept_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_WIN32 || ACE_HAS_AIO_CALLS */ -#endif /* ACE_ASYNCH_ACCEPTOR_C */ diff --git a/deps/acelite/ace/Asynch_Acceptor.h b/deps/acelite/ace/Asynch_Acceptor.h deleted file mode 100644 index 03efa702e..000000000 --- a/deps/acelite/ace/Asynch_Acceptor.h +++ /dev/null @@ -1,274 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Asynch_Acceptor.h - * - * @author Irfan Pyarali (irfan@cs.wustl.edu) - */ -//============================================================================= - -#ifndef ACE_ASYNCH_ACCEPTOR_H -#define ACE_ASYNCH_ACCEPTOR_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS) -// This only works on platforms that support async i/o. - -#include "ace/Default_Constants.h" -#include "ace/Asynch_IO.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward declarations -class ACE_Message_Block; -class ACE_INET_Addr; - -/** - * @class ACE_Asynch_Acceptor - * - * @brief This class is an example of the Acceptor Pattern. This class - * will accept new connections and create new HANDLER to handle - * the new connections. - * - * Unlike the ACE_Acceptor, however, this class is designed to - * be used asynchronously. - */ -template -class ACE_Asynch_Acceptor : public ACE_Handler -{ -public: - /// A do nothing constructor. - ACE_Asynch_Acceptor (void); - - /// Virtual destruction - virtual ~ACE_Asynch_Acceptor (void); - - /** - * @c open starts one or more asynchronous accept requests on a - * @a address. Each accept operation may optionally read an - * initial buffer from the new connection when accepted. - * - * @param address The address to listen/accept connections on. - * If the address does not specify a port, a random - * port is selected and bound. - * @param bytes_to_read Optional, specifies the maximum number of bytes - * to read with the accept. The buffer for the initial - * data is allocated internally and passed to the - * @c ACE_Service_Handler::open() hook method. It is - * legitimate only during the @c open() method and must - * be copied if required after @c open() returns. - * This pre-read function works only on Windows. - * @param pass_addresses Optional, a non-zero value indicates that - * the local and peer addresses should be passed to the - * associated @c ACE_Service_Handler::addresses() method - * after any call to @c validate_new_connection() and prior - * to the @c open() hook method call. - * @param backlog Optional, defaulting to @c ACE_DEFAULT_ASYNCH_BACKLOG (which - * can be adjusted in your platform's @c config.h file). - * Specifies the listening backlog for the listening socket. - * @param reuse_addr Optional, indicates whether the @c SO_REUSEADDR - * option is set on the listening socket or not. - * @param proactor Optional, pointer to the @c ACE_Proactor to use for - * demultiplexing asynchronous accepts. If 0, the - * process's singleton @c ACE_Proactor is used. - * @param validate_new_connection Optional, if true, this object's - * @c validate_connection() method is called after - * the accept completes, but before the service handler's - * @c open() hook method is called. If @c - * validate_connection() returns -1, the newly-accepted - * socket is immediately closed, and the @c addresses() - * method is not called. - * @param reissue_accept Optional, if non-zero (the default), a new - * asynchronous accept operation is started after each - * completion, whether the completion is for success or - * failure, and whether or not a successfully-accepted - * connection is subsequently refused. - * @param number_of_initial_accepts Optional, the number of asynchronous - * accepts that are started immediately. If -1 (the - * default), the value of @a backlog is used. - * - * @note On Windows, the peer address is only available at the time - * the connection is accepted. Therefore, if you require the peer - * address on Windows, do not rely on the - * @c ACE_SOCK::get_remote_addr() method - it won't work. You must - * supply a non-zero value for @a pass_addresses and obtain the - * peer address in the @c ACE_Service_Handler::addresses() method. - * - * @see ACE_INET_Addr - * @see ACE_Service_Handler - */ - virtual int open (const ACE_INET_Addr &address, - size_t bytes_to_read = 0, - bool pass_addresses = false, - int backlog = ACE_DEFAULT_ASYNCH_BACKLOG, - int reuse_addr = 1, - ACE_Proactor *proactor = 0, - bool validate_new_connection = false, - int reissue_accept = 1, - int number_of_initial_accepts = -1); - - /// Get the underlying handle. - virtual ACE_HANDLE get_handle (void) const; - - /** - * Set the underlying listen handle. It is the user's responsibility - * to make sure that the old listen handle has been appropriately - * closed and the all outstanding asynchronous operations have - * either completed or have been canceled on the old listen handle. - */ - virtual int set_handle (ACE_HANDLE handle); - - /// This initiates a new asynchronous accept operation. - /** - * You need only call this method if the @a reissue_accept argument - * passed to @c open() was 0. - */ - virtual int accept (size_t bytes_to_read = 0, const void *act = 0); - - /** - * Cancels all pending accepts operations issued by this object. - * - * @note On Windows, only accept operations initiated by the calling thread - * are canceled. - */ - virtual int cancel (void); - - /** - * Template method to validate peer before service is opened. - * This method is called after a new connection is accepted if the - * @a validate_connection argument to @c open() was non-zero or - * the @c validate_new_connection() method is called to turn this - * feature on. The default implementation returns 0. Users can - * reimplement this method to perform validation of the peer - * using it's address, running an authentication procedure (such as - * SSL) or anything else necessary or desireable. The return value - * from this method determines whether or not ACE will continue - * opening the service or abort the connection. - * - * @param result Result of the connection acceptance. - * @param remote Peer's address. - * @param local Local address connection was accepted at. - * - * @retval -1 ACE_Asynch_Acceptor will close the connection, and - * the service will not be opened. - * @retval 0 Service opening will proceeed. - */ - virtual int validate_connection (const ACE_Asynch_Accept::Result& result, - const ACE_INET_Addr &remote, - const ACE_INET_Addr& local); - - /** - * Template method for deciding whether to reissue accept. - * - * This hook method is called after each accept completes to decide if - * another accept should be initiated. If the method returns a non-zero - * value, another accept is initiated. - * - * The default implementation always returns the value passed as the - * @c open() method's @a reissue_accept argument. That value can also - * be changed using the @c reissue_accept() method. - */ - virtual int should_reissue_accept (void); - - // - // These are low level tweaking methods - // - - /// Get flag that indicates if parsing and passing of addresses to - /// the service_handler is necessary. - virtual bool pass_addresses (void) const; - - /// Set flag that indicates if parsing and passing of addresses to - /// the service_handler is necessary. - virtual void pass_addresses (bool new_value); - - /// Get flag that indicates if address validation is required. - virtual bool validate_new_connection (void) const; - - /// Set flag that indicates if address validation is required. - virtual void validate_new_connection (bool new_value); - - /// Get flag that indicates if a new accept should be reissued when a accept - /// completes. - virtual int reissue_accept (void) const; - - /// Set flag that indicates if a new accept should be reissued when a accept - /// completes. - virtual void reissue_accept (int new_value); - - /// Get bytes to be read with the call. - virtual size_t bytes_to_read (void) const; - - /// Set bytes to be read with the call. - virtual void bytes_to_read (size_t new_value); - -protected: - - /// This is called when an outstanding accept completes. - virtual void handle_accept (const ACE_Asynch_Accept::Result &result); - - /// Return the listen handle. - ACE_HANDLE handle (void) const; - /// Set the listen handle. - void handle (ACE_HANDLE h); - - /// This parses the address from read buffer. - void parse_address (const ACE_Asynch_Accept::Result &result, - ACE_INET_Addr &remote_address, - ACE_INET_Addr &local_address); - - /// Return the asynch accept object. - ACE_Asynch_Accept &asynch_accept (void); - - /** - * This is the template method used to create new handler. - * Subclasses must overwrite this method if a new handler creation - * strategy is required. - */ - virtual HANDLER *make_handler (void); - -private: - /// Handle used to listen for new connections. - ACE_HANDLE listen_handle_; - - /// Asynch_Accept used to make life easier :-) - ACE_Asynch_Accept asynch_accept_; - - /// Flag that indicates if parsing of addresses is necessary. - bool pass_addresses_; - - /// Flag that indicates if address validation is required. - bool validate_new_connection_; - - /// Flag that indicates if a new accept should be reissued when a - /// accept completes. - int reissue_accept_; - - /// Bytes to be read with the call. - size_t bytes_to_read_; - - /// Address family used to open this object. Obtained from @a address passed - /// to @c open(). - int addr_family_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Asynch_Acceptor.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Asynch_Acceptor.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#endif /* ACE_HAS_WIN32_OVERLAPPED_IO || ACE_HAS_AIO_CALLS */ -#include /**/ "ace/post.h" -#endif /* ACE_ASYNCH_ACCEPTOR_H */ diff --git a/deps/acelite/ace/Asynch_Connector.cpp b/deps/acelite/ace/Asynch_Connector.cpp deleted file mode 100644 index 5391ca5ad..000000000 --- a/deps/acelite/ace/Asynch_Connector.cpp +++ /dev/null @@ -1,268 +0,0 @@ -#ifndef ACE_ASYNCH_CONNECTOR_CPP -#define ACE_ASYNCH_CONNECTOR_CPP - -#include "ace/Asynch_Connector.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if (defined (ACE_WIN32) || defined (ACE_HAS_AIO_CALLS)) && !defined(ACE_HAS_WINCE) -// This only works on platforms that support async I/O. - -#include "ace/OS_NS_sys_socket.h" -#include "ace/OS_Memory.h" -#include "ace/Flag_Manip.h" -#include "ace/Log_Category.h" -#include "ace/Message_Block.h" -#include "ace/INET_Addr.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Asynch_Connector::ACE_Asynch_Connector (void) - : pass_addresses_ (false), - validate_new_connection_ (false) -{ -} - -template -ACE_Asynch_Connector::~ACE_Asynch_Connector (void) -{ - //this->asynch_connect_.close (); -} - -template int -ACE_Asynch_Connector::open (bool pass_addresses, - ACE_Proactor *proactor, - bool validate_new_connection) -{ - this->proactor (proactor); - this->pass_addresses_ = pass_addresses; - this->validate_new_connection_ = validate_new_connection; - - // Initialize the ACE_Asynch_Connect - if (this->asynch_connect_.open (*this, - ACE_INVALID_HANDLE, - 0, - this->proactor ()) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Asynch_Connect::open")), - -1); - return 0; -} - -template int -ACE_Asynch_Connector::connect (const ACE_INET_Addr & remote_sap, - const ACE_INET_Addr & local_sap, - int reuse_addr, - const void *act) -{ - // Initiate asynchronous connect - if (this->asynch_connect_.connect (ACE_INVALID_HANDLE, - remote_sap, - local_sap, - reuse_addr, - act) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Asynch_Connect::connect")), - -1); - return 0; -} - -template void -ACE_Asynch_Connector::handle_connect (const ACE_Asynch_Connect::Result &result) -{ - // Variable for error tracking - int error = 0; - - // If the asynchronous connect fails. - if (!result.success () || - result.connect_handle () == ACE_INVALID_HANDLE) - { - error = 1; - } - - if (result.error () != 0) - { - error = 1; - } - - // set blocking mode - if (!error && - ACE::clr_flags - (result.connect_handle (), ACE_NONBLOCK) != 0) - { - error = 1; - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Asynch_Connector::handle_connect : Set blocking mode"))); - } - - // Parse the addresses. - ACE_INET_Addr local_address; - ACE_INET_Addr remote_address; - if (!error && - (this->validate_new_connection_ || this->pass_addresses_)) - this->parse_address (result, - remote_address, - local_address); - - // Call validate_connection even if there was an error - it's the only - // way the application can learn the connect disposition. - if (this->validate_new_connection_ && - this->validate_connection (result, remote_address, local_address) == -1) - { - error = 1; - } - - HANDLER *new_handler = 0; - if (!error) - { - // The Template method - new_handler = this->make_handler (); - if (new_handler == 0) - { - error = 1; - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Asynch_Connector::handle_connect : Making of new handler failed"))); - } - } - - // If no errors - if (!error) - { - // Update the Proactor. - new_handler->proactor (this->proactor ()); - - // Pass the addresses - if (this->pass_addresses_) - new_handler->addresses (remote_address, - local_address); - - // Pass the ACT - if (result.act () != 0) - new_handler->act (result.act ()); - - // Set up the handler's new handle value - new_handler->handle (result.connect_handle ()); - - ACE_Message_Block mb; - - // Initiate the handler with empty message block; - new_handler->open (result.connect_handle (), mb); - } - - // On failure, no choice but to close the socket - if (error && - result.connect_handle() != ACE_INVALID_HANDLE) - ACE_OS::closesocket (result.connect_handle ()); -} - -template int -ACE_Asynch_Connector::validate_connection - (const ACE_Asynch_Connect::Result &, - const ACE_INET_Addr & /* remote_address */, - const ACE_INET_Addr & /* local_address */) -{ - // Default implementation always validates the remote address. - return 0; -} - -template int -ACE_Asynch_Connector::cancel (void) -{ - return this->asynch_connect_.cancel (); -} - -template void -ACE_Asynch_Connector::parse_address (const ACE_Asynch_Connect::Result &result, - ACE_INET_Addr &remote_address, - ACE_INET_Addr &local_address) -{ -#if defined (ACE_HAS_IPV6) - // Getting the addresses. - sockaddr_in6 local_addr; - sockaddr_in6 remote_addr; -#else - // Getting the addresses. - sockaddr_in local_addr; - sockaddr_in remote_addr; -#endif /* ACE_HAS_IPV6 */ - - // Get the length. - int local_size = sizeof (local_addr); - int remote_size = sizeof (remote_addr); - - // Get the local address. - if (ACE_OS::getsockname (result.connect_handle (), - reinterpret_cast (&local_addr), - &local_size) < 0) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT("%p\n"), - ACE_TEXT("ACE_Asynch_Connector:: failed"))); - - // Get the remote address. - if (ACE_OS::getpeername (result.connect_handle (), - reinterpret_cast (&remote_addr), - &remote_size) < 0) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT("%p\n"), - ACE_TEXT("ACE_Asynch_Connector:: failed"))); - - // Set the addresses. - local_address.set (reinterpret_cast (&local_addr), - local_size); - remote_address.set (reinterpret_cast (&remote_addr), - remote_size); - - return; -} - - -template ACE_Asynch_Connect & -ACE_Asynch_Connector::asynch_connect (void) -{ - return this->asynch_connect_; -} - -template HANDLER * -ACE_Asynch_Connector::make_handler (void) -{ - // Default behavior - HANDLER *handler = 0; - ACE_NEW_RETURN (handler, HANDLER, 0); - return handler; -} - -template bool -ACE_Asynch_Connector::pass_addresses (void) const -{ - return this->pass_addresses_; -} - -template void -ACE_Asynch_Connector::pass_addresses (bool new_value) -{ - this->pass_addresses_ = new_value; -} - -template bool -ACE_Asynch_Connector::validate_new_connection (void) const -{ - return this->validate_new_connection_; -} - -template void -ACE_Asynch_Connector::validate_new_connection (bool new_value) -{ - this->validate_new_connection_ = new_value; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_WIN32 || ACE_HAS_AIO_CALLS */ -#endif /* ACE_ASYNCH_CONNECTOR_CPP */ diff --git a/deps/acelite/ace/Asynch_Connector.h b/deps/acelite/ace/Asynch_Connector.h deleted file mode 100644 index 584c29fb0..000000000 --- a/deps/acelite/ace/Asynch_Connector.h +++ /dev/null @@ -1,168 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Asynch_Connector.h - * - * @author Alexander Libman - */ -//============================================================================= - -#ifndef ACE_ASYNCH_CONNECTOR_H -#define ACE_ASYNCH_CONNECTOR_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if (defined (ACE_WIN32) || defined (ACE_HAS_AIO_CALLS)) && !defined(ACE_HAS_WINCE) -// This only works on platforms that support async i/o. - -#include "ace/Asynch_IO.h" -#include "ace/INET_Addr.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward declarations -class ACE_Message_Block; - -/** - * @class ACE_Asynch_Connector - * - * @brief This class is an example of the Connector pattern. This class - * will establish new connections and create new HANDLER objects to handle - * the new connections. - * - * Unlike the ACE_Connector, however, this class is designed to - * be used asynchronously with the ACE Proactor framework. - */ - -template -class ACE_Asynch_Connector : public ACE_Handler -{ -public: - /// A do nothing constructor. - ACE_Asynch_Connector (void); - - /// Virtual destruction - virtual ~ACE_Asynch_Connector (void); - - /** - * This opens asynch connector - */ - virtual int open (bool pass_addresses = false, - ACE_Proactor *proactor = 0, - bool validate_new_connection = true); - - /// This initiates a new asynchronous connect - virtual int connect (const ACE_INET_Addr &remote_sap, - const ACE_INET_Addr &local_sap = - (const ACE_INET_Addr &)ACE_Addr::sap_any, - int reuse_addr = 1, - const void *act = 0); - - /** - * This cancels all pending accepts operations that were issued by - * the calling thread. - * - * @note On Windows, this method does not cancel connect operations - * issued by other threads. - * - * @note On POSIX, delegates cancelation to ACE_POSIX_Asynch_Connect. - */ - virtual int cancel (void); - - - /** - * Template method to validate peer before service is opened. - * This method is called when the connection attempt completes, - * whether it succeeded or failed, if the @a validate_connection - * argument to @c open() was non-zero or the @c validate_new_connection() - * method is called to turn this feature on. The default implementation - * returns 0. Users can (and probably should) reimplement this method - * to learn about the success or failure of the connection attempt. - * If the connection completed successfully, this method can be used to - * perform validation of the peer using it's address, running an - * authentication procedure (such as SSL) or anything else necessary or - * desireable. The return value from this method determines whether or - * not ACE will continue opening the service or abort the connection. - * - * @param result Result of the connection acceptance. Use - * result.success() to determine success or failure of - * the connection attempt. - * @param remote Peer's address. If the connection failed, this object - * is undefined. - * @param local Local address connection was completed from. If the - * connection failed, this object is undefined. - * - * @retval -1 ACE_Asynch_Connector will close the connection, and - * the service will not be opened. - * @retval 0 Service opening will proceeed. - * @return Return value is ignored if the connection attempt failed. - */ - virtual int validate_connection (const ACE_Asynch_Connect::Result& result, - const ACE_INET_Addr &remote, - const ACE_INET_Addr& local); - - // - // These are low level tweaking methods - // - - /// Set and get flag that indicates if parsing and passing of - /// addresses to the service_handler is necessary. - virtual bool pass_addresses (void) const; - virtual void pass_addresses (bool new_value); - - /// Set and get flag that indicates if address validation is - /// required. - virtual bool validate_new_connection (void) const; - virtual void validate_new_connection (bool new_value); - -protected: - - /// This is called when an outstanding accept completes. - virtual void handle_connect (const ACE_Asynch_Connect::Result &result); - - - /// This parses the address from read buffer. - void parse_address (const ACE_Asynch_Connect::Result &result, - ACE_INET_Addr &remote_address, - ACE_INET_Addr &local_address); - - /// Return the asynch Connect object. - ACE_Asynch_Connect & asynch_connect (void); - - /** - * This is the template method used to create new handler. - * Subclasses must overwrite this method if a new handler creation - * strategy is required. - */ - virtual HANDLER *make_handler (void); - -private: - /// Asynch_Connect used to make life easier :-) - ACE_Asynch_Connect asynch_connect_; - - /// Flag that indicates if parsing of addresses is necessary. - bool pass_addresses_; - - /// Flag that indicates if address validation is required. - bool validate_new_connection_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Asynch_Connector.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Asynch_Connector.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#endif /* ACE_WIN32 || ACE_HAS_AIO_CALLS */ -#include /**/ "ace/post.h" -#endif /* ACE_ASYNCH_CONNECTOR_H */ diff --git a/deps/acelite/ace/Asynch_IO.cpp b/deps/acelite/ace/Asynch_IO.cpp deleted file mode 100644 index f50cdc33d..000000000 --- a/deps/acelite/ace/Asynch_IO.cpp +++ /dev/null @@ -1,1410 +0,0 @@ -#include "ace/Asynch_IO.h" - -#if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS) -// This only works on platforms with Asynchronous IO - -#include "ace/Proactor.h" -#include "ace/Message_Block.h" -#include "ace/INET_Addr.h" -#include "ace/Asynch_IO_Impl.h" -#include "ace/os_include/os_errno.h" -#include "ace/Truncate.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -size_t -ACE_Asynch_Result::bytes_transferred (void) const -{ - return this->implementation ()->bytes_transferred (); -} - -const void * -ACE_Asynch_Result::act (void) const -{ - return this->implementation ()->act (); -} - -int -ACE_Asynch_Result::success (void) const -{ - return this->implementation ()->success (); -} - -const void * -ACE_Asynch_Result::completion_key (void) const -{ - return this->implementation ()->completion_key (); -} - -unsigned long -ACE_Asynch_Result::error (void) const -{ - return this->implementation ()->error (); -} - -ACE_HANDLE -ACE_Asynch_Result::event (void) const -{ - return this->implementation ()->event (); -} - -unsigned long -ACE_Asynch_Result::offset (void) const -{ - return this->implementation ()->offset (); -} - -unsigned long -ACE_Asynch_Result::offset_high (void) const -{ - return this->implementation ()->offset_high (); -} - -int -ACE_Asynch_Result::priority (void) const -{ - return this->implementation ()->priority (); -} - -int -ACE_Asynch_Result::signal_number (void) const -{ - return this->implementation ()->signal_number (); -} - -ACE_Asynch_Result::ACE_Asynch_Result (ACE_Asynch_Result_Impl *implementation) - : implementation_ (implementation) -{ -} - -ACE_Asynch_Result::~ACE_Asynch_Result (void) -{ - // Proactor deletes the implementation when the finishes. -} - -ACE_Asynch_Result_Impl * -ACE_Asynch_Result::implementation (void) const -{ - return this->implementation_; -} - -// ********************************************************************* - -int -ACE_Asynch_Operation::open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor) -{ - return this->implementation ()->open (handler.proxy (), - handle, - completion_key, - proactor); -} - -int -ACE_Asynch_Operation::cancel (void) -{ - if (0 == this->implementation ()) - { - errno = EFAULT; - return -1; - } - return this->implementation ()->cancel (); -} - -ACE_Proactor * -ACE_Asynch_Operation::proactor (void) const -{ - if (0 == this->implementation ()) - { - errno = EFAULT; - return 0; - } - return this->implementation ()->proactor (); -} - -ACE_Asynch_Operation::ACE_Asynch_Operation (void) -{ -} - -ACE_Asynch_Operation::~ACE_Asynch_Operation (void) -{ -} - -ACE_Proactor * -ACE_Asynch_Operation::get_proactor (ACE_Proactor *user_proactor, - ACE_Handler &handler) const -{ - if (user_proactor == 0) - { - // Grab the singleton proactor if proactor> is zero - user_proactor = handler.proactor (); - if (user_proactor == 0) - user_proactor = ACE_Proactor::instance (); - } - - return user_proactor; -} - -// ************************************************************ - -ACE_Asynch_Read_Stream::ACE_Asynch_Read_Stream (void) - : implementation_ (0) -{ -} - -ACE_Asynch_Read_Stream::~ACE_Asynch_Read_Stream (void) -{ - // Delete the implementation. - delete this->implementation_; - this->implementation_ = 0; -} - -int -ACE_Asynch_Read_Stream::open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor) -{ - // Get a proactor for/from the user. - proactor = this->get_proactor (proactor, handler); - - // Now let us get the implementation initialized. - if ((this->implementation_ = proactor->create_asynch_read_stream ()) == 0) - return -1; - - // Call the method of the base class. - return ACE_Asynch_Operation::open (handler, - handle, - completion_key, - proactor); -} - -int -ACE_Asynch_Read_Stream::read (ACE_Message_Block &message_block, - size_t bytes_to_read, - const void *act, - int priority, - int signal_number) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->read (message_block, - bytes_to_read, - act, - priority, - signal_number); -} - -#if defined (ACE_HAS_WIN32_OVERLAPPED_IO) -int -ACE_Asynch_Read_Stream::readv (ACE_Message_Block &message_block, - size_t bytes_to_read, - const void *act, - int priority, - int signal_number) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->readv (message_block, - bytes_to_read, - act, - priority, - signal_number); -} -#endif /* ACE_HAS_WIN32_OVERLAPPED_IO */ - -ACE_Asynch_Operation_Impl * -ACE_Asynch_Read_Stream::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - -size_t -ACE_Asynch_Read_Stream::Result::bytes_to_read (void) const -{ - return this->implementation ()->bytes_to_read (); -} - -ACE_Message_Block & -ACE_Asynch_Read_Stream::Result::message_block (void) const -{ - return this->implementation ()->message_block (); -} - -ACE_HANDLE -ACE_Asynch_Read_Stream::Result::handle (void) const -{ - return this->implementation ()->handle (); -} - -ACE_Asynch_Read_Stream::Result::Result (ACE_Asynch_Read_Stream_Result_Impl *implementation) - : ACE_Asynch_Result (implementation), - implementation_ (implementation) -{ -} - -ACE_Asynch_Read_Stream::Result::~Result (void) -{ - // Proactor will delete the implementation after is - // finished. -} - -ACE_Asynch_Read_Stream_Result_Impl * -ACE_Asynch_Read_Stream::Result::implementation (void) const -{ - return this->implementation_; -} - -// *************************************************** - -ACE_Asynch_Write_Stream::ACE_Asynch_Write_Stream (void) - : implementation_ (0) -{ -} - -ACE_Asynch_Write_Stream::~ACE_Asynch_Write_Stream (void) -{ - // Delete the implementation. - delete this->implementation_; - this->implementation_ = 0; -} - -int -ACE_Asynch_Write_Stream::open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor) -{ - // Get a proactor for/from the user. - proactor = this->get_proactor (proactor, handler); - - // Now let us get the implementation initialized. - if ((this->implementation_ = proactor->create_asynch_write_stream ()) == 0) - return -1; - - // Call the method of the base class. - return ACE_Asynch_Operation::open (handler, - handle, - completion_key, - proactor); -} - -int -ACE_Asynch_Write_Stream::write (ACE_Message_Block &message_block, - size_t bytes_to_write, - const void *act, - int priority, - int signal_number) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->write (message_block, - bytes_to_write, - act, - priority, - signal_number); -} - -#if defined (ACE_HAS_WIN32_OVERLAPPED_IO) -int -ACE_Asynch_Write_Stream::writev (ACE_Message_Block &message_block, - size_t bytes_to_write, - const void *act, - int priority, - int signal_number) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->writev (message_block, - bytes_to_write, - act, - priority, - signal_number); -} -#endif /* ACE_HAS_WIN32_OVERLAPPED_IO */ - -ACE_Asynch_Operation_Impl * -ACE_Asynch_Write_Stream::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - -size_t -ACE_Asynch_Write_Stream::Result::bytes_to_write (void) const -{ - return this->implementation ()->bytes_to_write (); -} - -ACE_Message_Block & -ACE_Asynch_Write_Stream::Result::message_block (void) const -{ - return this->implementation ()->message_block (); -} - -ACE_HANDLE -ACE_Asynch_Write_Stream::Result::handle (void) const -{ - return this->implementation ()->handle (); -} - -ACE_Asynch_Write_Stream::Result::Result (ACE_Asynch_Write_Stream_Result_Impl *implementation) - : ACE_Asynch_Result (implementation), - implementation_ (implementation) -{ -} - -ACE_Asynch_Write_Stream::Result::~Result (void) -{ - // Proactor will delte the implementation when the call - // finishes. -} - -ACE_Asynch_Write_Stream_Result_Impl * -ACE_Asynch_Write_Stream::Result::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - -ACE_Asynch_Read_File::ACE_Asynch_Read_File (void) - : implementation_ (0) -{ -} - -ACE_Asynch_Read_File::~ACE_Asynch_Read_File (void) -{ - // Delete the implementation. - delete this->implementation_; - this->implementation_ = 0; -} - -int -ACE_Asynch_Read_File::open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor) -{ - // Get a proactor for/from the user. - proactor = this->get_proactor (proactor, handler); - - // Now let us get the implementation initialized. - if ((this->implementation_ = proactor->create_asynch_read_file ()) == 0) - return -1; - - // Call the method of the base class. - return ACE_Asynch_Operation::open (handler, - handle, - completion_key, - proactor); -} - -int -ACE_Asynch_Read_File::read (ACE_Message_Block &message_block, - size_t bytes_to_read, - unsigned long offset, - unsigned long offset_high, - const void *act, - int priority, - int signal_number) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->read (message_block, - bytes_to_read, - offset, - offset_high, - act, - priority, - signal_number); -} - -#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) -int -ACE_Asynch_Read_File::readv (ACE_Message_Block &message_block, - size_t bytes_to_read, - unsigned long offset, - unsigned long offset_high, - const void *act, - int priority, - int signal_number) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->readv (message_block, - bytes_to_read, - offset, - offset_high, - act, - priority, - signal_number); -} -#endif /* (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) */ - -ACE_Asynch_Operation_Impl * -ACE_Asynch_Read_File::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - -ACE_Asynch_Read_File::Result::Result (ACE_Asynch_Read_File_Result_Impl *implementation) - : ACE_Asynch_Read_Stream::Result (implementation), - implementation_ (implementation) -{ -} - -ACE_Asynch_Read_File::Result::~Result (void) -{ - // Proactor will delete the implementation when call - // completes. -} - -ACE_Asynch_Read_File_Result_Impl * -ACE_Asynch_Read_File::Result::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - -ACE_Asynch_Write_File::ACE_Asynch_Write_File (void) - : implementation_ (0) -{ -} - -ACE_Asynch_Write_File::~ACE_Asynch_Write_File (void) -{ - // Delete the implementation. - delete this->implementation_; - this->implementation_ = 0; -} - -int -ACE_Asynch_Write_File::open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor) -{ - // Get a proactor for/from the user. - proactor = this->get_proactor (proactor, handler); - - // Now let us get the implementation initialized. - if ((this->implementation_ = proactor->create_asynch_write_file ()) == 0) - return -1; - - // Call the method of the base class. - return ACE_Asynch_Operation::open (handler, - handle, - completion_key, - proactor); -} - -int -ACE_Asynch_Write_File::write (ACE_Message_Block &message_block, - size_t bytes_to_write, - unsigned long offset, - unsigned long offset_high, - const void *act, - int priority, - int signal_number) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->write (message_block, - bytes_to_write, - offset, - offset_high, - act, - priority, - signal_number); -} - -#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) -int -ACE_Asynch_Write_File::writev (ACE_Message_Block &message_block, - size_t bytes_to_write, - unsigned long offset, - unsigned long offset_high, - const void *act, - int priority, - int signal_number) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->writev (message_block, - bytes_to_write, - offset, - offset_high, - act, - priority, - signal_number); -} -#endif /* (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) */ - -ACE_Asynch_Operation_Impl * -ACE_Asynch_Write_File::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - -ACE_Asynch_Write_File::Result::Result (ACE_Asynch_Write_File_Result_Impl *implementation) - : ACE_Asynch_Write_Stream::Result (implementation), - implementation_ (implementation) -{ -} - -ACE_Asynch_Write_File::Result::~Result (void) -{ - // Proactor will delete the implementation when the call - // completes. -} - -ACE_Asynch_Write_File_Result_Impl * -ACE_Asynch_Write_File::Result::implementation (void) const -{ - return this->implementation_; -} - -// ********************************************************************* - -ACE_Asynch_Accept::ACE_Asynch_Accept (void) - : implementation_ (0) -{ -} - -ACE_Asynch_Accept::~ACE_Asynch_Accept (void) -{ - // Delete the implementation. - delete this->implementation_; - this->implementation_ = 0; -} - -int -ACE_Asynch_Accept::open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor) -{ - // Get a proactor for/from the user. - proactor = this->get_proactor (proactor, handler); - - // Now let us get the implementation initialized. - if ((this->implementation_ = proactor->create_asynch_accept ()) == 0) - return -1; - - // Call the method of the base class. - return ACE_Asynch_Operation::open (handler, - handle, - completion_key, - proactor); -} - -int -ACE_Asynch_Accept::accept (ACE_Message_Block &message_block, - size_t bytes_to_read, - ACE_HANDLE accept_handle, - const void *act, - int priority, - int signal_number, - int addr_family) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->accept (message_block, - bytes_to_read, - accept_handle, - act, - priority, - signal_number, - addr_family); -} - -ACE_Asynch_Operation_Impl * -ACE_Asynch_Accept::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - -size_t -ACE_Asynch_Accept::Result::bytes_to_read (void) const -{ - return this->implementation ()->bytes_to_read (); -} - -ACE_Message_Block & -ACE_Asynch_Accept::Result::message_block (void) const -{ - return this->implementation ()->message_block (); -} - -ACE_HANDLE -ACE_Asynch_Accept::Result::listen_handle (void) const -{ - return this->implementation ()->listen_handle (); -} - -ACE_HANDLE -ACE_Asynch_Accept::Result::accept_handle (void) const -{ - return this->implementation ()->accept_handle (); -} - -ACE_Asynch_Accept::Result::Result (ACE_Asynch_Accept_Result_Impl *implementation) - : ACE_Asynch_Result (implementation), - implementation_ (implementation) -{ -} - -ACE_Asynch_Accept::Result::~Result (void) -{ - // Proactor will delete the implementation when the call - // completes. -} - -ACE_Asynch_Accept_Result_Impl * -ACE_Asynch_Accept::Result::implementation (void) const -{ - return this->implementation_; -} - - - -// ********************************************************************* - -ACE_Asynch_Connect::ACE_Asynch_Connect (void) - : implementation_ (0) -{ -} - -ACE_Asynch_Connect::~ACE_Asynch_Connect (void) -{ - // Delete the implementation. - delete this->implementation_; - this->implementation_ = 0; -} - -int -ACE_Asynch_Connect::open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor) -{ - // Get a proactor for/from the user. - proactor = this->get_proactor (proactor, handler); - - // Now let us get the implementation initialized. - if ((this->implementation_ = proactor->create_asynch_connect ()) == 0) - return -1; - - // Call the method of the base class. - return ACE_Asynch_Operation::open (handler, - handle, - completion_key, - proactor); -} - -int -ACE_Asynch_Connect::connect (ACE_HANDLE connect_handle, - const ACE_Addr & remote_sap, - const ACE_Addr & local_sap, - int reuse_addr, - const void *act, - int priority, - int signal_number) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->connect (connect_handle, - remote_sap, - local_sap, - reuse_addr, - act, - priority, - signal_number); -} - -ACE_Asynch_Operation_Impl * -ACE_Asynch_Connect::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - -ACE_Asynch_Connect::Result::Result (ACE_Asynch_Connect_Result_Impl *implementation) - : ACE_Asynch_Result (implementation), - implementation_ (implementation) -{ -} - -ACE_Asynch_Connect::Result::~Result (void) -{ - // Proactor will delete the implementation when the call - // completes. -} - -ACE_HANDLE -ACE_Asynch_Connect::Result::connect_handle (void) const -{ - return this->implementation ()->connect_handle (); -} - - -ACE_Asynch_Connect_Result_Impl * -ACE_Asynch_Connect::Result::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - -ACE_Asynch_Transmit_File::ACE_Asynch_Transmit_File (void) - : implementation_ (0) -{ -} - -ACE_Asynch_Transmit_File::~ACE_Asynch_Transmit_File (void) -{ - // Delete the implementation. - delete this->implementation_; - this->implementation_ = 0; -} - -int -ACE_Asynch_Transmit_File::open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor) -{ - // Get a proactor for/from the user. - proactor = this->get_proactor (proactor, handler); - - // Now let us get the implementation initialized. - if ((this->implementation_ = proactor->create_asynch_transmit_file ()) == 0) - return -1; - - // Call the method of the base class. - return ACE_Asynch_Operation::open (handler, - handle, - completion_key, - proactor); -} - -int -ACE_Asynch_Transmit_File::transmit_file (ACE_HANDLE file, - Header_And_Trailer *header_and_trailer, - size_t bytes_to_write, - unsigned long offset, - unsigned long offset_high, - size_t bytes_per_send, - unsigned long flags, - const void *act, - int priority, - int signal_number) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->transmit_file (file, - header_and_trailer, - bytes_to_write, - offset, - offset_high, - bytes_per_send, - flags, - act, - priority, - signal_number); -} - -ACE_Asynch_Operation_Impl * -ACE_Asynch_Transmit_File::implementation (void) const -{ - return this->implementation_; -} - -// **************************************************************************** - -ACE_HANDLE -ACE_Asynch_Transmit_File::Result::socket (void) const -{ - return this->implementation ()->socket (); -} - -ACE_HANDLE -ACE_Asynch_Transmit_File::Result::file (void) const -{ - return this->implementation ()->file (); -} - -ACE_Asynch_Transmit_File::Header_And_Trailer * -ACE_Asynch_Transmit_File::Result::header_and_trailer (void) const -{ - return this->implementation ()->header_and_trailer (); -} - -size_t -ACE_Asynch_Transmit_File::Result::bytes_to_write (void) const -{ - return this->implementation ()->bytes_to_write (); -} - -size_t -ACE_Asynch_Transmit_File::Result::bytes_per_send (void) const -{ - return this->implementation ()->bytes_per_send (); -} - -unsigned long -ACE_Asynch_Transmit_File::Result::flags (void) const -{ - return this->implementation ()->flags (); -} - -ACE_Asynch_Transmit_File::Result::Result (ACE_Asynch_Transmit_File_Result_Impl *implementation) - : ACE_Asynch_Result (implementation), - implementation_ (implementation) -{ -} - -ACE_Asynch_Transmit_File::Result::~Result (void) -{ -} - -ACE_Asynch_Transmit_File_Result_Impl * -ACE_Asynch_Transmit_File::Result::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - -ACE_Asynch_Transmit_File::Header_And_Trailer::Header_And_Trailer (ACE_Message_Block *header, - size_t header_bytes, - ACE_Message_Block *trailer, - size_t trailer_bytes) - : header_ (header), - header_bytes_ (header_bytes), - trailer_ (trailer), - trailer_bytes_ (trailer_bytes) -{ -} - -ACE_Asynch_Transmit_File::Header_And_Trailer::~Header_And_Trailer (void) -{ -} - -void -ACE_Asynch_Transmit_File::Header_And_Trailer::header_and_trailer (ACE_Message_Block *header, - size_t header_bytes, - ACE_Message_Block *trailer, - size_t trailer_bytes) -{ - this->header (header); - this->header_bytes (header_bytes); - this->trailer (trailer); - this->trailer_bytes (trailer_bytes); -} - -ACE_Message_Block * -ACE_Asynch_Transmit_File::Header_And_Trailer::header (void) const -{ - return this->header_; -} - -void -ACE_Asynch_Transmit_File::Header_And_Trailer::header (ACE_Message_Block *message_block) -{ - this->header_ = message_block; -} - -size_t -ACE_Asynch_Transmit_File::Header_And_Trailer::header_bytes (void) const -{ - return this->header_bytes_; -} - -void -ACE_Asynch_Transmit_File::Header_And_Trailer::header_bytes (size_t bytes) -{ - this->header_bytes_ = bytes; -} - -ACE_Message_Block * -ACE_Asynch_Transmit_File::Header_And_Trailer::trailer (void) const -{ - return this->trailer_; -} - -void -ACE_Asynch_Transmit_File::Header_And_Trailer::trailer (ACE_Message_Block *message_block) -{ - this->trailer_ = message_block; -} - -size_t -ACE_Asynch_Transmit_File::Header_And_Trailer::trailer_bytes (void) const -{ - return this->trailer_bytes_; -} - -void -ACE_Asynch_Transmit_File::Header_And_Trailer::trailer_bytes (size_t bytes) -{ - this->trailer_bytes_ = bytes; -} - -ACE_LPTRANSMIT_FILE_BUFFERS -ACE_Asynch_Transmit_File::Header_And_Trailer::transmit_buffers (void) -{ - // If both are zero, return zero - if (this->header_ == 0 && this->trailer_ == 0) - { - return 0; - } - else - { - // Something is valid - - // If header is valid, set the fields - if (this->header_ != 0) - { - this->transmit_buffers_.Head = this->header_->rd_ptr (); -#if defined (ACE_WIN64) || defined (ACE_WIN32) - this->transmit_buffers_.HeadLength = - ACE_Utils::truncate_cast (this->header_bytes_); -#else - this->transmit_buffers_.HeadLength = this->header_bytes_; -#endif /* ACE_WIN64 || ACE_WIN32 */ - } - else - { - this->transmit_buffers_.Head = 0; - this->transmit_buffers_.HeadLength = 0; - } - - // If trailer is valid, set the fields - if (this->trailer_ != 0) - { - this->transmit_buffers_.Tail = this->trailer_->rd_ptr (); -#if defined(ACE_WIN64) || defined (ACE_WIN32) - this->transmit_buffers_.TailLength = - ACE_Utils::truncate_cast (this->trailer_bytes_); -#else - this->transmit_buffers_.TailLength = this->trailer_bytes_; -#endif /* ACE_WIN64 || ACE_WIN32 */ - } - else - { - this->transmit_buffers_.Tail = 0; - this->transmit_buffers_.TailLength = 0; - } - - // Return the transmit buffers - return &this->transmit_buffers_; - } -} - -// ********************************************************************* - -ACE_Handler::ACE_Handler (void) - : proactor_ (0), handle_ (ACE_INVALID_HANDLE) -{ - ACE_Handler::Proxy *p; - ACE_NEW (p, ACE_Handler::Proxy (this)); - this->proxy_.reset (p); -} - -ACE_Handler::ACE_Handler (ACE_Proactor *d) - : proactor_ (d), handle_ (ACE_INVALID_HANDLE) -{ - ACE_Handler::Proxy *p; - ACE_NEW (p, ACE_Handler::Proxy (this)); - this->proxy_.reset (p); -} - -ACE_Handler::~ACE_Handler (void) -{ - ACE_Handler::Proxy *p = this->proxy_.get (); - if (p) - p->reset (); -} - -void -ACE_Handler::handle_read_stream (const ACE_Asynch_Read_Stream::Result & /* result */) -{ -} - -void -ACE_Handler::handle_write_stream (const ACE_Asynch_Write_Stream::Result & /* result */) -{ -} - -void -ACE_Handler::handle_write_dgram (const ACE_Asynch_Write_Dgram::Result & /* result */) -{ -} - -void -ACE_Handler::handle_read_dgram (const ACE_Asynch_Read_Dgram::Result & /* result */) -{ -} - -void -ACE_Handler::handle_accept (const ACE_Asynch_Accept::Result & /* result */) -{ -} - -void -ACE_Handler::handle_connect (const ACE_Asynch_Connect::Result & /* result */) -{ -} - -void -ACE_Handler::handle_transmit_file (const ACE_Asynch_Transmit_File::Result & /* result */) -{ -} - -void -ACE_Handler::handle_read_file (const ACE_Asynch_Read_File::Result & /* result */) -{ -} - -void -ACE_Handler::handle_write_file (const ACE_Asynch_Write_File::Result & /* result */) -{ -} - -void -ACE_Handler::handle_time_out (const ACE_Time_Value & /* tv */, - const void * /* act */) -{ -} - -void -ACE_Handler::handle_wakeup (void) -{ -} - -ACE_Proactor * -ACE_Handler::proactor (void) -{ - return this->proactor_; -} - -void -ACE_Handler::proactor (ACE_Proactor *p) -{ - this->proactor_ = p; -} - -ACE_HANDLE -ACE_Handler::handle (void) const -{ - return this->handle_; -} - -void -ACE_Handler::handle (ACE_HANDLE h) -{ - this->handle_ = h; -} - -ACE_Refcounted_Auto_Ptr & -ACE_Handler::proxy (void) -{ - return this->proxy_; -} - -// ************************************************************ - -ACE_Service_Handler::ACE_Service_Handler (void) -{ -} - -ACE_Service_Handler::~ACE_Service_Handler (void) -{ -} - -void -ACE_Service_Handler::addresses (const ACE_INET_Addr & /* remote_address */, - const ACE_INET_Addr & /* local_address */ ) -{ -} - -void -ACE_Service_Handler::act (const void *) -{ -} - -void -ACE_Service_Handler::open (ACE_HANDLE, - ACE_Message_Block &) -{ -} - - -// ************************************************************ - -ACE_Asynch_Read_Dgram::ACE_Asynch_Read_Dgram (void) - : implementation_ (0) -{ -} - -ACE_Asynch_Read_Dgram::~ACE_Asynch_Read_Dgram (void) -{ - // Delete the implementation. - delete this->implementation_; - this->implementation_ = 0; -} - -int -ACE_Asynch_Read_Dgram::open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor) -{ - // Get a proactor for/from the user. - proactor = this->get_proactor (proactor, handler); - - // Now let us get the implementation initialized. - if ((this->implementation_ = proactor->create_asynch_read_dgram ()) == 0) - return -1; - - // Call the method of the base class. - return ACE_Asynch_Operation::open (handler, - handle, - completion_key, - proactor); -} - -ssize_t -ACE_Asynch_Read_Dgram::recv (ACE_Message_Block *message_block, - size_t &number_of_bytes_recvd, - int flags, - int protocol_family, - const void *act, - int priority, - int signal_number) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->recv (message_block, - number_of_bytes_recvd, - flags, - protocol_family, - act, - priority, - signal_number); -} - -ACE_Asynch_Operation_Impl * -ACE_Asynch_Read_Dgram::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - -int -ACE_Asynch_Read_Dgram::Result::remote_address (ACE_Addr& addr) const -{ - return this->implementation ()->remote_address (addr); -} - -ACE_Message_Block* -ACE_Asynch_Read_Dgram::Result::message_block (void) const -{ - return this->implementation ()->message_block (); -} - -int -ACE_Asynch_Read_Dgram::Result::flags (void) const -{ - return this->implementation ()->flags (); -} - -size_t -ACE_Asynch_Read_Dgram::Result::bytes_to_read (void) const -{ - return this->implementation ()->bytes_to_read (); -} - -ACE_HANDLE -ACE_Asynch_Read_Dgram::Result::handle (void) const -{ - return this->implementation ()->handle(); -} - -ACE_Asynch_Read_Dgram::Result::Result (ACE_Asynch_Read_Dgram_Result_Impl *implementation) -: ACE_Asynch_Result (implementation), - implementation_ (implementation) -{ -} - -ACE_Asynch_Read_Dgram::Result::~Result (void) -{ -} - -ACE_Asynch_Read_Dgram_Result_Impl * -ACE_Asynch_Read_Dgram::Result::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - - -ACE_Asynch_Write_Dgram::ACE_Asynch_Write_Dgram (void) - : implementation_ (0) -{ -} - -ACE_Asynch_Write_Dgram::~ACE_Asynch_Write_Dgram (void) -{ - // Delete the implementation. - delete this->implementation_; - this->implementation_ = 0; -} - -int -ACE_Asynch_Write_Dgram::open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor) -{ - // Get a proactor for/from the user. - proactor = this->get_proactor (proactor, handler); - - // Now let us get the implementation initialized. - if ((this->implementation_ = proactor->create_asynch_write_dgram ()) == 0) - return -1; - - // Call the method of the base class. - return ACE_Asynch_Operation::open (handler, - handle, - completion_key, - proactor); -} - -ssize_t -ACE_Asynch_Write_Dgram::send (ACE_Message_Block *message_block, - size_t &number_of_bytes_sent, - int flags, - const ACE_Addr& remote_addr, - const void *act, - int priority, - int signal_number) -{ - if (0 == this->implementation_) - { - errno = EFAULT; - return -1; - } - return this->implementation_->send (message_block, - number_of_bytes_sent, - flags, - remote_addr, - act, - priority, - signal_number); -} - -ACE_Asynch_Operation_Impl * -ACE_Asynch_Write_Dgram::implementation (void) const -{ - return this->implementation_; -} - -// ************************************************************ - -size_t -ACE_Asynch_Write_Dgram::Result::bytes_to_write (void) const -{ - return this->implementation ()->bytes_to_write (); -} - -ACE_Message_Block* -ACE_Asynch_Write_Dgram::Result::message_block () const -{ - return this->implementation ()->message_block (); -} - -int -ACE_Asynch_Write_Dgram::Result::flags (void) const -{ - return this->implementation ()->flags (); -} - -ACE_HANDLE -ACE_Asynch_Write_Dgram::Result::handle (void) const -{ - return this->implementation ()->handle (); -} - -ACE_Asynch_Write_Dgram_Result_Impl * -ACE_Asynch_Write_Dgram::Result::implementation (void) const -{ - return this->implementation_; -} - -ACE_Asynch_Write_Dgram::Result::Result (ACE_Asynch_Write_Dgram_Result_Impl *implementation) -: ACE_Asynch_Result (implementation), - implementation_ (implementation) -{ -} - -ACE_Asynch_Write_Dgram::Result::~Result (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_WIN32_OVERLAPPED_IO || ACE_HAS_AIO_CALLS */ diff --git a/deps/acelite/ace/Asynch_IO.h b/deps/acelite/ace/Asynch_IO.h deleted file mode 100644 index 78db98fcd..000000000 --- a/deps/acelite/ace/Asynch_IO.h +++ /dev/null @@ -1,1736 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Asynch_IO.h - * - * This works on Win32 (defined (ACE_WIN32) && !defined - * (ACE_HAS_WINCE)) platforms and on POSIX4 platforms with {aio_*} - * routines (defined (ACE_HAS_AIO_CALLS)) - * - * On Win32 platforms, the implementation of - * {ACE_Asynch_Transmit_File} and {ACE_Asynch_Accept} are only - * supported if ACE_HAS_WINSOCK2 is defined or you are on WinNT 4.0 - * or higher. - * - * @author Irfan Pyarali - * @author Tim Harrison - * @author Alexander Babu Arulanthu - * @author Roger Tragin - * @author Alexander Libman - */ -//============================================================================= - -#ifndef ACE_ASYNCH_IO_H -#define ACE_ASYNCH_IO_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS) - -#include "ace/Synch_Traits.h" -#if defined (ACE_HAS_THREADS) -# include "ace/Thread_Mutex.h" -#else -# include "ace/Null_Mutex.h" -#endif /* ACE_HAS_THREADS */ -#include "ace/Refcounted_Auto_Ptr.h" - -#include "ace/os_include/os_signal.h" -#include "ace/os_include/sys/os_socket.h" -#include "ace/os_include/sys/os_types.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -# if defined (ACE_HAS_WIN32_OVERLAPPED_IO) -typedef TRANSMIT_FILE_BUFFERS ACE_TRANSMIT_FILE_BUFFERS; -typedef LPTRANSMIT_FILE_BUFFERS ACE_LPTRANSMIT_FILE_BUFFERS; -typedef PTRANSMIT_FILE_BUFFERS ACE_PTRANSMIT_FILE_BUFFERS; - -# define ACE_INFINITE INFINITE -# define ACE_STATUS_TIMEOUT STATUS_TIMEOUT -# define ACE_WAIT_FAILED WAIT_FAILED -# define ACE_WAIT_TIMEOUT WAIT_TIMEOUT -# else /* ACE_HAS_WIN32_OVERLAPPED_IO */ -struct ACE_TRANSMIT_FILE_BUFFERS -{ - void *Head; - size_t HeadLength; - void *Tail; - size_t TailLength; -}; -typedef ACE_TRANSMIT_FILE_BUFFERS* ACE_PTRANSMIT_FILE_BUFFERS; -typedef ACE_TRANSMIT_FILE_BUFFERS* ACE_LPTRANSMIT_FILE_BUFFERS; - -# if !defined (ACE_INFINITE) -# define ACE_INFINITE LONG_MAX -# endif /* ACE_INFINITE */ -# define ACE_STATUS_TIMEOUT LONG_MAX -# define ACE_WAIT_FAILED LONG_MAX -# define ACE_WAIT_TIMEOUT LONG_MAX -# endif /* ACE_HAS_WIN32_OVERLAPPED_IO */ - -// Forward declarations -class ACE_Proactor; -class ACE_Handler; -class ACE_Message_Block; -class ACE_INET_Addr; -class ACE_Addr; - -// Forward declarations -class ACE_Asynch_Result_Impl; -class ACE_Time_Value; - -/** - * @class ACE_Asynch_Result - * - * @brief An interface base class which allows users access to common - * information related to an asynchronous operation. - * - * An interface base class from which you can obtain some basic - * information like the number of bytes transferred, the ACT - * associated with the asynchronous operation, indication of - * success or failure, etc. Subclasses may want to store more - * information that is particular to the asynchronous operation - * it represents. - */ -class ACE_Export ACE_Asynch_Result -{ -public: - /// Number of bytes transferred by the operation. - size_t bytes_transferred (void) const; - - /// ACT associated with the operation. - const void *act (void) const; - - /// Did the operation succeed? - int success (void) const; - - /** - * This is the ACT associated with the handle on which the - * Asynch_Operation takes place. - * - * On WIN32, this returns the ACT associated with the handle when it - * was registered with the I/O completion port. - * - * @@ This is not implemented for POSIX4 platforms. Returns 0. - */ - const void *completion_key (void) const; - - /// Error value if the operation fails. - unsigned long error (void) const; - - /** - * On WIN32, this returns the event associated with the OVERLAPPED - * structure. - * - * This returns ACE_INVALID_HANDLE on POSIX4-Unix platforms. - */ - ACE_HANDLE event (void) const; - - /** - * This really makes sense only when doing file I/O. - * - * On WIN32, these are represented in the OVERLAPPED datastructure. - * - * @@ On POSIX4-Unix, offset_high should be supported using - * aiocb64. - */ - unsigned long offset (void) const; - unsigned long offset_high (void) const; - - /** - * Priority of the operation. - * - * On POSIX4-Unix, this is supported. Priority works like {nice} in - * Unix. Negative values are not allowed. 0 means priority of the - * operation same as the process priority. 1 means priority of the - * operation is one less than process. And so forth. - * - * On Win32, this is a no-op. - */ - int priority (void) const; - - /** - * POSIX4 real-time signal number to be used for the - * operation. {signal_number} ranges from ACE_SIGRTMIN to ACE_SIGRTMAX. By - * default, ACE_SIGRTMIN is used to issue {aio_} calls. This is a no-op - * on non-POSIX4 systems and returns 0. - */ - int signal_number (void) const; - - - /// Destructor. - virtual ~ACE_Asynch_Result (void); - -protected: - /// Constructor. This implementation will not be deleted. The - /// implementation will be deleted by the Proactor. - ACE_Asynch_Result (ACE_Asynch_Result_Impl *implementation); - - /// Get the implementation class. - ACE_Asynch_Result_Impl *implementation (void) const; - - /// Implementation class. - ACE_Asynch_Result_Impl *implementation_; -}; - -// Forward declarations -class ACE_Asynch_Operation_Impl; - -/** - * @class ACE_Asynch_Operation - * - * @brief This is an interface base class for all asynch - * operations. The resposiblility of this class is to forward - * all methods to its delegation/implementation class, e.g., - * ACE_WIN32_Asynch_Operation or ACE_POSIX_Asynch_Operation. - * - * There are some attributes and functionality which is common - * to all asychronous operations. The delegation classes of this - * class will factor out this code. - */ -class ACE_Export ACE_Asynch_Operation -{ -public: - /** - * Initializes the factory with information which will be used with - * each asynchronous call. If ({handle} == ACE_INVALID_HANDLE), - * {ACE_Handler::handle} will be called on the {handler} to get the - * correct handle. - */ - int open (ACE_Handler &handler, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor); - - /** - * (Attempts to) cancel the asynchronous operation pending against - * the {handle} registered with this Operation. - * - * All completion notifications for the I/O operations will occur - * normally. - * - * = Return Values: - * - * -1 : Operation failed. (can get only in POSIX). - * 0 : All the operations were cancelled. - * 1 : All the operations were already finished in this - * handle. Unable to cancel them. - * 2 : Atleast one of the requested operations cannot be - * cancelled. - * - * There is slight difference in the semantics between NT and POSIX - * platforms which is given below. - * - * = Win32 : - * - * cancels all pending accepts operations that were issued by the - * calling thread. The function does not cancel asynchronous - * operations issued by other threads. - * All I/O operations that are canceled will complete with the - * error ERROR_OPERATION_ABORTED. - * - * = POSIX: - * - * Attempts to cancel one or more asynchronous I/O requests - * currently outstanding against the {handle} registered in this - * operation. - * For requested operations that are successfully canceled, the - * associated error status is set to ECANCELED. - */ - int cancel (void); - - - // = Access methods. - - /// Return the underlying proactor. - ACE_Proactor* proactor (void) const; - - /// Destructor. - virtual ~ACE_Asynch_Operation (void); - -protected: - /// Constructor. - ACE_Asynch_Operation (void); - - /// Return the underlying implementation class. - virtual ACE_Asynch_Operation_Impl *implementation (void) const = 0; - - /// Get a proactor for/from the user - ACE_Proactor *get_proactor (ACE_Proactor *user_proactor, - ACE_Handler &handler) const; -}; - -// Forward declarations -class ACE_Asynch_Read_Stream_Result_Impl; -class ACE_Asynch_Read_Stream_Impl; - -/** - * @class ACE_Asynch_Read_Stream - * - * @brief This class is a factory for starting off asynchronous reads - * on a stream. This class forwards all methods to its - * implementation class. - * - * Once {open} is called, multiple asynchronous {read}s can - * started using this class. An ACE_Asynch_Read_Stream::Result - * will be passed back to the {handler} when the asynchronous - * reads completes through the {ACE_Handler::handle_read_stream} - * callback. - */ -class ACE_Export ACE_Asynch_Read_Stream : public ACE_Asynch_Operation -{ -public: - /// A do nothing constructor. - ACE_Asynch_Read_Stream (void); - - /// Destructor - virtual ~ACE_Asynch_Read_Stream (void); - - /** - * Initializes the factory with information which will be used with - * each asynchronous call. - * - * @param handler The ACE_Handler that will be called to handle completions - * for operations initiated using this factory. - * @param handle The handle that future read operations will use. - * If handle == @c ACE_INVALID_HANDLE, - * ACE_Handler::handle() will be called on @ handler - * to get the correct handle. - * - * @retval 0 for success. - * @retval -1 for failure; consult @c errno for further information. - */ - int open (ACE_Handler &handler, - ACE_HANDLE handle = ACE_INVALID_HANDLE, - const void *completion_key = 0, - ACE_Proactor *proactor = 0); - - /** - * Initiate an asynchronous read operation. - * - * @param message_block The ACE_Message_Block to receive the data. - * Received bytes will be placed in the block - * beginning at its current write pointer. - * If data is read, the message block's write - * pointer will be advanced by the number of - * bytes read. - * @param num_bytes_to_read The maximum number of bytes to read. - * @param act Asynchronous Completion Token; passed through to - * the completion handler in the Result object. - * @param priority Priority of the operation. On POSIX4-Unix, - * this is supported. Works like @c nice in Unix. - * Negative values are not allowed. 0 means - * priority of the operation same as the process - * priority. 1 means priority of the operation is - * one less than process priority, etc. - * Ignored on Windows. - * @param signal_number The POSIX4 real-time signal number to be used - * to signal completion of the operation. Values - * range from ACE_SIGRTMIN to ACE_SIGRTMAX. - * This argument is ignored on non-POSIX4 systems. - */ - int read (ACE_Message_Block &message_block, - size_t num_bytes_to_read, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - -#if defined (ACE_HAS_WIN32_OVERLAPPED_IO) - /** - * Same as above but with scatter support, through chaining of composite - * message blocks using the continuation field. - */ - int readv (ACE_Message_Block &message_block, - size_t num_bytes_to_read, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); -#endif /* defined (ACE_HAS_WIN32_OVERLAPPED_IO) */ - - /// Return the underlying implementation class. - // (this should be protected...) - virtual ACE_Asynch_Operation_Impl *implementation (void) const; - -protected: - /// Implementation class that all methods will be forwarded to. - ACE_Asynch_Read_Stream_Impl *implementation_; - -public: -/** - * @class Result - * - * @brief This is the class which will be passed back to the - * ACE_Handler::handle_read_stream when the asynchronous read completes. - * This class forwards all the methods to the implementation classes. - * - * This class has all the information necessary for the - * handler to uniquiely identify the completion of the - * asynchronous read. - */ - class ACE_Export Result : public ACE_Asynch_Result - { - /// The concrete implementation result classes only construct this - /// class. - friend class ACE_POSIX_Asynch_Read_Stream_Result; - friend class ACE_WIN32_Asynch_Read_Stream_Result; - - public: - /// The number of bytes which were requested at the start of the - /// asynchronous read. - size_t bytes_to_read (void) const; - - /// Message block which contains the read data. - ACE_Message_Block &message_block (void) const; - - /// I/O handle used for reading. - ACE_HANDLE handle (void) const; - - /// Get the implementation class. - ACE_Asynch_Read_Stream_Result_Impl *implementation (void) const; - - protected: - /// Constructor. - Result (ACE_Asynch_Read_Stream_Result_Impl *implementation); - - /// Destructor. - virtual ~Result (void); - - /// The implementation class. - ACE_Asynch_Read_Stream_Result_Impl *implementation_; - }; -private: - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Asynch_Read_Stream &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Asynch_Read_Stream (const ACE_Asynch_Read_Stream &)) -}; - -// Forward declarations -class ACE_Asynch_Write_Stream_Impl; -class ACE_Asynch_Write_Stream_Result_Impl; - -/** - * @class ACE_Asynch_Write_Stream - * - * @brief This class is a factory for initiating asynchronous writes - * on a connected TCP/IP stream. This class forwards all methods to its - * implementation class. - * - * Once open() is called, multiple asynchronous writes can be - * started using this class. An ACE_Asynch_Write_Stream::Result - * will be passed to the ACE_Handler::handle_write_stream() method on the - * opened ACE_Handler object when the asynchronous write completes. - */ -class ACE_Export ACE_Asynch_Write_Stream : public ACE_Asynch_Operation -{ -public: - /// A do nothing constructor. - ACE_Asynch_Write_Stream (void); - - /// Destructor. - virtual ~ACE_Asynch_Write_Stream (void); - - /** - * Initializes the factory with information which will be used with - * each asynchronous operation. - * - * @param handler ACE_Handler to be notified when operations initiated - * via this factory complete. The handle_write_stream() - * method will be called on this object. - * @param handle The socket handle to initiate write operations on. - * If handle is @c ACE_INVALID_HANDLE, - * ACE_Handler::handle() will be called on handler to - * get the handle value. - * @param completion_key A token that is passed to the completion handler. - * @param proactor The ACE_Proactor object which will control operation - * completion and dispatching the results to handler. - * If this is 0, the process's singleton ACE_Proactor - * will be used. - * - * @retval 0 for success. - * @retval -1 for failure; consult @c errno for further information. - */ - int open (ACE_Handler &handler, - ACE_HANDLE handle = ACE_INVALID_HANDLE, - const void *completion_key = 0, - ACE_Proactor *proactor = 0); - - /** - * Initiates an asynchronous write on a socket. If the operation completes - * the ACE_Handler object registered in open() will receive a completion - * callback via its handle_write_stream() method. - * - * @param bytes_to_write The number of bytes to write. - * @param message_block The ACE_Message_Block containing data to write. - * Data is written to the socket beginning at the - * block's rd_ptr. Upon successful completion - * of the write operation, the message_block rd_ptr - * is updated to reflect the data that was written. - * @param act Token that is passed through to the completion - * handler. - * @param priority Priority of the operation. This argument only has - * an affect on POSIX4-Unix. Works like @c nice in - * Unix; negative values are not allowed. 0 means - * priority of the operation same as the process - * priority. 1 means priority of the operation is one - * less than the process, and so forth. - * @param signal_number The POSIX4 real-time signal number to be used - * for the operation. signal_number ranges from - * ACE_SIGRTMIN to ACE_SIGRTMAX. This argument is - * not used on other platforms. - * - * @retval 0 for success, and the handle_write_stream associated - * with the opened ACE_Handler will be called. An - * instance of ACE_Asynch_Write_Stream::Result will be - * passed to the completion handler. - * @retval -1 for failure; consult @c errno for further information. - */ - int write (ACE_Message_Block &message_block, - size_t bytes_to_write, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - -#if defined (ACE_HAS_WIN32_OVERLAPPED_IO) - /** - * Same as above but with gather support, through chaining of composite - * message blocks using the continuation field. - */ - int writev (ACE_Message_Block &message_block, - size_t bytes_to_write, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); -#endif /* defined (ACE_HAS_WIN32_OVERLAPPED_IO) */ - - /// Return the underlying implementation class. - /// @todo (this should be protected...) - virtual ACE_Asynch_Operation_Impl *implementation (void) const; - -protected: - /// Implementation class that all methods will be forwarded to. - ACE_Asynch_Write_Stream_Impl *implementation_; - -public: -/** - * @class Result - * - * @brief This is that class which will be passed back to the - * ACE_Handler when the asynchronous write completes. This class - * forwards all the methods to the implementation class. - * - * This class has all the information necessary for the - * handler to uniquiely identify the completion of the - * asynchronous write. - */ - class ACE_Export Result : public ACE_Asynch_Result - { - /// The concrete implementation result classes only construct this - /// class. - friend class ACE_POSIX_Asynch_Write_Stream_Result; - friend class ACE_WIN32_Asynch_Write_Stream_Result; - - public: - /// The number of bytes which were requested at the start of the - /// asynchronous write. - size_t bytes_to_write (void) const; - - /// Message block that contains the data to be written. - ACE_Message_Block &message_block (void) const; - - /// I/O handle used for writing. - ACE_HANDLE handle (void) const; - - /// Get the implementation class. - ACE_Asynch_Write_Stream_Result_Impl *implementation (void) const; - - protected: - /// Constructor. - Result (ACE_Asynch_Write_Stream_Result_Impl *implementation); - - /// Destructor. - virtual ~Result (void); - - /// Implementation class. - ACE_Asynch_Write_Stream_Result_Impl *implementation_; - }; -private: - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Asynch_Write_Stream &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Asynch_Write_Stream (const ACE_Asynch_Write_Stream &)) -}; - -// Forward declarations -class ACE_Asynch_Read_File_Impl; -class ACE_Asynch_Read_File_Result_Impl; - -/** - * @class ACE_Asynch_Read_File - * - * @brief This class is a factory for starting off asynchronous reads - * on a file. This class forwards all methods to its - * implementation class. - * - * Once open() is called, multiple asynchronous reads can - * started using this class. An ACE_Asynch_Read_File::Result - * will be passed back to the completion handler's - * ACE_Handler::handle_read_file() method when each asynchronous - * read completes. - * This class differs slightly from ACE_Asynch_Read_Stream as it - * allows the user to specify an offset for the read. - */ -class ACE_Export ACE_Asynch_Read_File : public ACE_Asynch_Read_Stream -{ -public: - /// A do nothing constructor. - ACE_Asynch_Read_File (void); - - /// Destructor. - virtual ~ACE_Asynch_Read_File (void); - - /** - * Initializes the factory with information which will be used with - * each asynchronous operation. - * - * @param handler ACE_Handler to be notified when operations initiated - * via this factory complete. The - * ACE_Handler::handle_read_file() method will be - * called on this object. - * @param handle The file handle to initiate read operations on. - * If handle is @c ACE_INVALID_HANDLE, - * ACE_Handler::handle() will be called on handler to - * get the handle value. - * @param completion_key A token that is passed to the completion handler. - * @param proactor The ACE_Proactor object which will control operation - * completion and dispatching the results to handler. - * If this is 0, the process's singleton ACE_Proactor - * will be used. - * - * @retval 0 for success. - * @retval -1 for failure; consult @c errno for further information. - */ - int open (ACE_Handler &handler, - ACE_HANDLE handle = ACE_INVALID_HANDLE, - const void *completion_key = 0, - ACE_Proactor *proactor = 0); - - /** - * This starts off an asynchronous read. Upto {bytes_to_read} will - * be read and stored in the {message_block}. The read will start - * at {offset} from the beginning of the file. Priority of the - * operation is specified by {priority}. On POSIX4-Unix, this is - * supported. Works like {nice} in Unix. Negative values are not - * allowed. 0 means priority of the operation same as the process - * priority. 1 means priority of the operation is one less than - * process. And so forth. On Win32, this argument is a no-op. - * {signal_number} is the POSIX4 real-time signal number to be used - * for the operation. {signal_number} ranges from ACE_SIGRTMIN to - * ACE_SIGRTMAX. This argument is a no-op on non-POSIX4 systems. - */ - int read (ACE_Message_Block &message_block, - size_t bytes_to_read, - unsigned long offset = 0, - unsigned long offset_high = 0, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - -#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) - /** - * Same as above but with scatter support, through chaining of composite - * message blocks using the continuation field. - * @note In win32 Each data block payload must be at least the size of a system - * memory page and must be aligned on a system memory page size boundary - */ - int readv (ACE_Message_Block &message_block, - size_t bytes_to_read, - unsigned long offset = 0, - unsigned long offset_high = 0, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); -#endif /* (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) */ - - /// Return the underlying implementation class. - // (this should be protected...) - virtual ACE_Asynch_Operation_Impl *implementation (void) const; - -protected: - /// Delegation/implementation class that all methods will be - /// forwarded to. - ACE_Asynch_Read_File_Impl *implementation_; - -public: -/** - * @class Result - * - * @brief This is that class which will be passed back to the - * {handler} when the asynchronous read completes. This class - * forwards all the methods to the implementation class. - * - * This class has all the information necessary for the - * {handler} to uniquiely identify the completion of the - * asynchronous read. - * This class differs slightly from - * ACE_Asynch_Read_Stream::Result as it calls back - * {ACE_Handler::handle_read_file} on the {handler} instead of - * {ACE_Handler::handle_read_stream}. No additional state is - * required by this class as ACE_Asynch_Result can store the - * {offset}. - */ - class ACE_Export Result : public ACE_Asynch_Read_Stream::Result - { - /// The concrete implementation result classes only construct this - /// class. - friend class ACE_POSIX_Asynch_Read_File_Result; - friend class ACE_WIN32_Asynch_Read_File_Result; - - public: - /// Get the implementation class. - ACE_Asynch_Read_File_Result_Impl *implementation (void) const; - - protected: - /// Constructor. This implementation will not be deleted. - Result (ACE_Asynch_Read_File_Result_Impl *implementation); - - /// Destructor. - virtual ~Result (void); - - /// The implementation class. - ACE_Asynch_Read_File_Result_Impl *implementation_; - - private: - /// Here just to provide an dummpy implementation, since the - /// one auto generated by MSVC is flagged as infinitely recursive - void operator= (Result &) {} - }; -private: - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Asynch_Read_File &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Asynch_Read_File (const ACE_Asynch_Read_File &)) -}; - -// Forward declarations -class ACE_Asynch_Write_File_Impl; -class ACE_Asynch_Write_File_Result_Impl; - -/** - * @class ACE_Asynch_Write_File - * - * @brief This class is a factory for starting off asynchronous writes - * on a file. This class forwards all methods to its - * implementation class. - * - * Once {open} is called, multiple asynchronous {write}s can be - * started using this class. A ACE_Asynch_Write_File::Result - * will be passed back to the {handler} when the asynchronous - * writes completes through the {ACE_Handler::handle_write_file} - * callback. - * This class differs slightly from ACE_Asynch_Write_Stream as - * it allows the user to specify an offset for the write. - */ -class ACE_Export ACE_Asynch_Write_File : public ACE_Asynch_Write_Stream -{ -public: - /// A do nothing constructor. - ACE_Asynch_Write_File (void); - - /// Destructor. - virtual ~ACE_Asynch_Write_File (void); - - /** - * Initializes the factory with information which will be used with - * each asynchronous call. If ({handle} == ACE_INVALID_HANDLE), - * {ACE_Handler::handle} will be called on the {handler} to get the - * correct handle. - */ - int open (ACE_Handler &handler, - ACE_HANDLE handle = ACE_INVALID_HANDLE, - const void *completion_key = 0, - ACE_Proactor *proactor = 0); - - /** - * This starts off an asynchronous write. Upto {bytes_to_write} - * will be written from the {message_block}, starting at the - * block's {rd_ptr}. The write will go to the file, starting - * {offset} bytes from the beginning of the file. Priority of the - * operation is specified by {priority}. On POSIX4-Unix, this is - * supported. Works like {nice} in Unix. Negative values are not - * allowed. 0 means priority of the operation same as the process - * priority. 1 means priority of the operation is one less than - * process. And so forth. On Win32, this is a no-op. - * {signal_number} is the POSIX4 real-time signal number to be used - * for the operation. {signal_number} ranges from ACE_SIGRTMIN to - * ACE_SIGRTMAX. This argument is a no-op on non-POSIX4 systems. - */ - int write (ACE_Message_Block &message_block, - size_t bytes_to_write, - unsigned long offset = 0, - unsigned long offset_high = 0, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - -#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) - /** - * Same as above but with gather support, through chaining of composite - * message blocks using the continuation field. - * @note In win32 Each data block payload must be at least the size of a system - * memory page and must be aligned on a system memory page size boundary - */ - int writev (ACE_Message_Block &message_block, - size_t bytes_to_write, - unsigned long offset = 0, - unsigned long offset_high = 0, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); -#endif /* (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) */ - - /// Return the underlying implementation class. - // (this should be protected...) - virtual ACE_Asynch_Operation_Impl *implementation (void) const; - -protected: - /// Implementation object. - ACE_Asynch_Write_File_Impl *implementation_; - -public: -/** - * @class Result - * - * @brief This is that class which will be passed back to the - * {handler} when the asynchronous write completes. This class - * forwards all the methods to the implementation class. - * - * This class has all the information necessary for the - * {handler} to uniquiely identify the completion of the - * asynchronous write. - * This class differs slightly from - * ACE_Asynch_Write_Stream::Result as it calls back - * {ACE_Handler::handle_write_file} on the {handler} instead - * of {ACE_Handler::handle_write_stream}. No additional state - * is required by this class as ACE_Asynch_Result can store - * the {offset}. - */ - class ACE_Export Result : public ACE_Asynch_Write_Stream::Result - { - /// The concrete implementation result classes only construct this - /// class. - friend class ACE_POSIX_Asynch_Write_File_Result; - friend class ACE_WIN32_Asynch_Write_File_Result; - - public: - /// Get the implementation class. - ACE_Asynch_Write_File_Result_Impl *implementation (void) const; - - protected: - /// Constructor. This implementation will not be deleted. - Result (ACE_Asynch_Write_File_Result_Impl *implementation); - - /// Destructor. - virtual ~Result (void); - - /// The implementation class. - ACE_Asynch_Write_File_Result_Impl *implementation_; - - private: - /// Here just to provide an dummpy implementation, since the - /// one auto generated by MSVC is flagged as infinitely recursive - void operator= (Result &) {}; - }; -private: - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Asynch_Write_File &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Asynch_Write_File (const ACE_Asynch_Write_File &)) -}; - -// Forward declarations -class ACE_Asynch_Accept_Result_Impl; -class ACE_Asynch_Accept_Impl; - -/** - * @class ACE_Asynch_Accept - * - * @brief This class is a factory for starting off asynchronous accepts - * on a listen handle. This class forwards all methods to its - * implementation class. - * - * Once {open} is called, multiple asynchronous {accept}s can - * started using this class. A ACE_Asynch_Accept::Result will - * be passed back to the {handler} when the asynchronous accept - * completes through the {ACE_Handler::handle_accept} - * callback. - */ -class ACE_Export ACE_Asynch_Accept : public ACE_Asynch_Operation -{ -public: - /// A do nothing constructor. - ACE_Asynch_Accept (void); - - /// Destructor. - virtual ~ACE_Asynch_Accept (void); - - /** - * Initializes the factory with information which will be used with - * each asynchronous call. If ({handle} == ACE_INVALID_HANDLE), - * {ACE_Handler::handle} will be called on the {handler} to get the - * correct handle. - */ - int open (ACE_Handler &handler, - ACE_HANDLE handle = ACE_INVALID_HANDLE, - const void *completion_key = 0, - ACE_Proactor *proactor = 0); - - /** - * This starts off an asynchronous accept. The asynchronous accept - * call also allows any initial data to be returned to the - * handler specified to @c open(). - * @param message_block A message block to receive initial data, as well - * as the local and remote addresses when the - * connection is made. Since the block receives - * the addresses regardless of whether or not - * initial data is available or requested, the - * message block size must be at least - * @a bytes_to_read plus two times the size of - * the addresses used (IPv4 or IPv6). - * @param bytes_to_read The maximum number of bytes of initial data - * to read into @a message_block. - * @param accept_handle The handle that the new connection will be - * accepted on. If @c INVALID_HANDLE, a new - * handle will be created using @a addr_family. - * @param act Value to be passed in result when operation - * completes. - * @param priority Priority of the operation. On POSIX4-Unix, this - * is supported. Works like @c nice in Unix. - * Negative values are not allowed. 0 means - * priority of the operation same as the process - * priority. 1 means priority of the operation is - * one less than process. And so forth. - * On Win32, this argument is ignored. - * @param signal_number The POSIX4 real-time signal number to be used - * for the operation. Value range is from - * @c ACE_SIGRTMIN to @c ACE_SIGRTMAX. - * This argument is ignored on non-POSIX4 systems. - * @param addr_family The address family to use if @a accept_handle - * is @c ACE_INVALID_HANDLE and a new handle must - * be opened. Values are @c AF_INET and @c PF_INET6. - */ - int accept (ACE_Message_Block &message_block, - size_t bytes_to_read, - ACE_HANDLE accept_handle = ACE_INVALID_HANDLE, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN, - int addr_family = AF_INET); - - /// Return the underlying implementation class. - // (this should be protected...) - virtual ACE_Asynch_Operation_Impl *implementation (void) const; - -protected: - /// Delegation/implementation class that all methods will be - /// forwarded to. - ACE_Asynch_Accept_Impl *implementation_; - -public: -/** - * @class Result - * - * @brief This is that class which will be passed back to the - * {handler} when the asynchronous accept completes. - * - * This class has all the information necessary for the - * {handler} to uniquiely identify the completion of the - * asynchronous accept. - */ - class ACE_Export Result : public ACE_Asynch_Result - { - /// The concrete implementation result classes only construct this - /// class. - friend class ACE_POSIX_Asynch_Accept_Result; - friend class ACE_WIN32_Asynch_Accept_Result; - - public: - /// The number of bytes which were requested at the start of the - /// asynchronous accept. - size_t bytes_to_read (void) const; - - /// Message block which contains the read data. - ACE_Message_Block &message_block (void) const; - - /// I/O handle used for accepting new connections. - ACE_HANDLE listen_handle (void) const; - - /// I/O handle for the new connection. - ACE_HANDLE accept_handle (void) const; - - /// Get the implementation. - ACE_Asynch_Accept_Result_Impl *implementation (void) const; - - protected: - /// Constructor. Implementation will not be deleted. - Result (ACE_Asynch_Accept_Result_Impl *implementation); - - /// Destructor. - virtual ~Result (void); - - /// Implementation class. - ACE_Asynch_Accept_Result_Impl *implementation_; - }; -private: - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Asynch_Accept &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Asynch_Accept (const ACE_Asynch_Accept &)) -}; -// Forward declarations -class ACE_Asynch_Connect_Result_Impl; -class ACE_Asynch_Connect_Impl; - -/** - * @class ACE_Asynch_Connect - * - * @brief This class is a factory for starting off asynchronous connects - * This class forwards all methods to its implementation class. - * - * Once @c open is called, multiple asynchronous connect operationss can - * started using this class. A ACE_Asynch_Connect::Result will - * be passed back to the associated ACE_Handler when the asynchronous connect - * completes through the ACE_Handler::handle_connect() callback. - */ -class ACE_Export ACE_Asynch_Connect : public ACE_Asynch_Operation -{ -public: - /// A do nothing constructor. - ACE_Asynch_Connect (void); - - /// Destructor. - virtual ~ACE_Asynch_Connect (void); - - /** - * Initializes the factory with information which will be used with - * each asynchronous call. - * - * @note @arg handle is ignored and should be @c ACE_INVALID_HANDLE. - */ - int open (ACE_Handler &handler, - ACE_HANDLE handle = ACE_INVALID_HANDLE, - const void *completion_key = 0, - ACE_Proactor *proactor = 0); - - /** - * This starts off an asynchronous Connect. - */ - int connect (ACE_HANDLE connect_handle, - const ACE_Addr & remote_sap, - const ACE_Addr & local_sap, - int reuse_addr, - const void *act=0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - - /// Return the underlying implementation class. - // (this should be protected...) - virtual ACE_Asynch_Operation_Impl *implementation (void) const; - -protected: - /// Delegation/implementation class that all methods will be - /// forwarded to. - ACE_Asynch_Connect_Impl *implementation_; - -public: -/** - * @class Result - * - * @brief This is that class which will be passed back to the - * handler when the asynchronous connect completes. - * - * This class has all the information necessary for the - * handler to uniquely identify the completion of the - * asynchronous connect. - */ - class ACE_Export Result : public ACE_Asynch_Result - { - /// The concrete implementation result classes only construct this - /// class. - friend class ACE_POSIX_Asynch_Connect_Result; - friend class ACE_WIN32_Asynch_Connect_Result; - - public: - - /// I/O handle for the connection. - ACE_HANDLE connect_handle (void) const; - - /// Get the implementation. - ACE_Asynch_Connect_Result_Impl *implementation (void) const; - - protected: - /// Constructor. Implementation will not be deleted. - Result (ACE_Asynch_Connect_Result_Impl *implementation); - - /// Destructor. - virtual ~Result (void); - - /// Implementation class. - ACE_Asynch_Connect_Result_Impl *implementation_; - }; -private: - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Asynch_Connect &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Asynch_Connect (const ACE_Asynch_Connect &)) -}; - -// Forward declarations -class ACE_Asynch_Transmit_File_Result_Impl; -class ACE_Asynch_Transmit_File_Impl; - -/** - * @class ACE_Asynch_Transmit_File - * - * @brief This class is a factory for starting off asynchronous - * transmit files on a stream. - * - * Once {open} is called, multiple asynchronous {transmit_file}s - * can started using this class. A - * ACE_Asynch_Transmit_File::Result will be passed back to the - * {handler} when the asynchronous transmit file completes - * through the {ACE_Handler::handle_transmit_file} callback. - * The transmit_file function transmits file data over a - * connected network connection. The function uses the operating - * system's cache manager to retrieve the file data. This - * function provides high-performance file data transfer over - * network connections. This function would be of great use in - * a Web Server, Image Server, etc. - */ -class ACE_Export ACE_Asynch_Transmit_File : public ACE_Asynch_Operation -{ -public: - // Forward declarations - class Header_And_Trailer; - - /// A do nothing constructor. - ACE_Asynch_Transmit_File (void); - - /// Destructor. - virtual ~ACE_Asynch_Transmit_File (void); - - /** - * Initializes the factory with information which will be used with - * each asynchronous call. If ({handle} == ACE_INVALID_HANDLE), - * {ACE_Handler::handle} will be called on the {handler} to get the - * correct handle. - */ - int open (ACE_Handler &handler, - ACE_HANDLE handle = ACE_INVALID_HANDLE, - const void *completion_key = 0, - ACE_Proactor *proactor = 0); - - /** - * This starts off an asynchronous transmit file. The {file} is a - * handle to an open file. {header_and_trailer} is a pointer to a - * data structure that contains pointers to data to send before and - * after the file data is sent. Set this parameter to 0 if you only - * want to transmit the file data. Upto {bytes_to_write} will be - * written to the {socket}. If you want to send the entire file, - * let {bytes_to_write} = 0. {bytes_per_send} is the size of each - * block of data sent per send operation. Please read the Win32 - * documentation on what the flags should be. Priority of the - * operation is specified by {priority}. On POSIX4-Unix, this is - * supported. Works like {nice} in Unix. Negative values are not - * allowed. 0 means priority of the operation same as the process - * priority. 1 means priority of the operation is one less than - * process. And so forth. On Win32, this is a no-op. - * {signal_number} is the POSIX4 real-time signal number to be used - * for the operation. {signal_number} ranges from ACE_SIGRTMIN to - * ACE_SIGRTMAX. This argument is a no-op on non-POSIX4 systems. - */ - int transmit_file (ACE_HANDLE file, - Header_And_Trailer *header_and_trailer = 0, - size_t bytes_to_write = 0, - unsigned long offset = 0, - unsigned long offset_high = 0, - size_t bytes_per_send = 0, - unsigned long flags = 0, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - - /// Return the underlying implementation class. - // (this should be protected...) - virtual ACE_Asynch_Operation_Impl *implementation (void) const; - -protected: - /// The implementation class. - ACE_Asynch_Transmit_File_Impl *implementation_; - -public: -/** - * @class Result - * - * @brief This is that class which will be passed back to the - * {handler} when the asynchronous transmit file completes. - * - * This class has all the information necessary for the - * {handler} to uniquiely identify the completion of the - * asynchronous transmit file. - */ - class ACE_Export Result : public ACE_Asynch_Result - { - /// The concrete implementation result classes only construct this - /// class. - friend class ACE_POSIX_Asynch_Transmit_File_Result; - friend class ACE_WIN32_Asynch_Transmit_File_Result; - - public: - /// Socket used for transmitting the file. - ACE_HANDLE socket (void) const; - - /// File from which the data is read. - ACE_HANDLE file (void) const; - - /// Header and trailer data associated with this transmit file. - Header_And_Trailer *header_and_trailer (void) const; - - /// The number of bytes which were requested at the start of the - /// asynchronous transmit file. - size_t bytes_to_write (void) const; - - /// Number of bytes per send requested at the start of the transmit - /// file. - size_t bytes_per_send (void) const; - - /// Flags which were passed into transmit file. - unsigned long flags (void) const; - - /// Get the implementation class. - ACE_Asynch_Transmit_File_Result_Impl *implementation (void) const; - - protected: - /// Constructor. - Result (ACE_Asynch_Transmit_File_Result_Impl *implementation); - - /// Destructor. - virtual ~Result (void); - - /// The implementation class. - ACE_Asynch_Transmit_File_Result_Impl *implementation_; - }; - -/** - * @class Header_And_Trailer - * - * @brief The class defines a data structure that contains pointers - * to data to send before and after the file data is sent. - * - * This class provides a wrapper over TRANSMIT_FILE_BUFFERS - * and provided a consistent use of ACE_Message_Blocks. - */ - class ACE_Export Header_And_Trailer - { - public: - /// Constructor. - Header_And_Trailer (ACE_Message_Block *header = 0, - size_t header_bytes = 0, - ACE_Message_Block *trailer = 0, - size_t trailer_bytes = 0); - - /// Destructor - virtual ~Header_And_Trailer (void); - - /// This method allows all the member to be set in one fell swoop. - void header_and_trailer (ACE_Message_Block *header = 0, - size_t header_bytes = 0, - ACE_Message_Block *trailer = 0, - size_t trailer_bytes = 0); - - /// Get header which goes before the file data. - ACE_Message_Block *header (void) const; - - /// Set header which goes before the file data. - void header (ACE_Message_Block *message_block); - - /// Get size of the header data. - size_t header_bytes (void) const; - - /// Set size of the header data. - void header_bytes (size_t bytes); - - /// Get trailer which goes after the file data. - ACE_Message_Block *trailer (void) const; - - /// Set trailer which goes after the file data. - void trailer (ACE_Message_Block *message_block); - - /// Get size of the trailer data. - size_t trailer_bytes (void) const; - - /// Set size of the trailer data. - void trailer_bytes (size_t bytes); - - /// Conversion routine. - ACE_LPTRANSMIT_FILE_BUFFERS transmit_buffers (void); - - protected: - /// Header data. - ACE_Message_Block *header_; - - /// Size of header data. - size_t header_bytes_; - - /// Trailer data. - ACE_Message_Block *trailer_; - - /// Size of trailer data. - size_t trailer_bytes_; - - /// Target data structure. - ACE_TRANSMIT_FILE_BUFFERS transmit_buffers_; - }; -private: - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Asynch_Transmit_File &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Asynch_Transmit_File (const ACE_Asynch_Transmit_File &)) -}; - - -// Forward declarations -class ACE_Asynch_Read_Dgram_Result_Impl; -class ACE_Asynch_Read_Dgram_Impl; -class ACE_Addr; - -/** - * @class ACE_Asynch_Read_Dgram - * - * @brief This class is a factory for starting off asynchronous reads - * on a UDP socket. This class forwards all methods to its - * implementation class. - * - * Once {open} is called, multiple asynchronous {read}s can be - * started using this class. An ACE_Asynch_Read_Dgram::Result - * will be passed back to the {handler} when the asynchronous - * reads completes through the {ACE_Handler::handle_read_dgram} - * callback. - */ -class ACE_Export ACE_Asynch_Read_Dgram : public ACE_Asynch_Operation -{ -public: - /// A do nothing constructor. - ACE_Asynch_Read_Dgram (void); - - /// Destructor - virtual ~ACE_Asynch_Read_Dgram (void); - - /** - * Initializes the factory with information which will be used with - * each asynchronous call. If ({handle} == ACE_INVALID_HANDLE), - * {ACE_Handler::handle} will be called on the {handler} to get the - * correct handle. - */ - int open (ACE_Handler &handler, - ACE_HANDLE handle = ACE_INVALID_HANDLE, - const void *completion_key = 0, - ACE_Proactor *proactor = 0); - - /** This starts off an asynchronous read. Upto - * {message_block->total_size()} will be read and stored in the - * {message_block}. {message_block}'s {wr_ptr} will be updated to reflect - * the added bytes if the read operation is successfully completed. - * Return code of 1 means immediate success and {number_of_bytes_recvd} - * will contain number of bytes read. The {ACE_Handler::handle_read_dgram} - * method will still be called. Return code of 0 means the IO will - * complete proactively. Return code of -1 means there was an error, use - * errno to get the error code. - * - * Scatter/gather is supported on WIN32 by using the {message_block->cont()} - * method. Up to ACE_IOV_MAX {message_block}'s are supported. Upto - * {message_block->size()} bytes will be read into each {message block} for - * a total of {message_block->total_size()} bytes. All {message_block}'s - * {wr_ptr}'s will be updated to reflect the added bytes for each - * {message_block} - * - * Priority of the operation is specified by {priority}. On POSIX4-Unix, - * this is supported. Works like {nice} in Unix. Negative values are not - * allowed. 0 means priority of the operation same as the process - * priority. 1 means priority of the operation is one less than - * process. And so forth. On Win32, {priority} is a no-op. - * {signal_number} is the POSIX4 real-time signal number to be used - * for the operation. {signal_number} ranges from ACE_SIGRTMIN to - * ACE_SIGRTMAX. This argument is a no-op on non-POSIX4 systems. - */ - ssize_t recv (ACE_Message_Block *message_block, - size_t &number_of_bytes_recvd, - int flags, - int protocol_family = PF_INET, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - - /// Return the underlying implementation class. - // (this should be protected...) - virtual ACE_Asynch_Operation_Impl *implementation (void) const; - -protected: - /// Implementation class that all methods will be forwarded to. - ACE_Asynch_Read_Dgram_Impl *implementation_; - -public: -/** - * @class Result - * - * @brief This is the class which will be passed back to the - * {handler} when the asynchronous read completes. This class - * forwards all the methods to the implementation classes. - * - * This class has all the information necessary for the - * {handler} to uniquiely identify the completion of the - * asynchronous read. - */ - class ACE_Export Result : public ACE_Asynch_Result - { - /// The concrete implementation result classes only construct this - /// class. - friend class ACE_POSIX_Asynch_Read_Dgram_Result; - friend class ACE_WIN32_Asynch_Read_Dgram_Result; - - public: - /// The number of bytes which were requested at the start of the - /// asynchronous read. - size_t bytes_to_read (void) const; - - /// Message block which contains the read data - ACE_Message_Block *message_block (void) const; - - /// The flags used in the read - int flags (void) const; - - /// The address of where the packet came from - int remote_address (ACE_Addr& addr) const; - - /// I/O handle used for reading. - ACE_HANDLE handle (void) const; - - /// Get the implementation class. - ACE_Asynch_Read_Dgram_Result_Impl *implementation (void) const; - - protected: - /// Constructor. - Result (ACE_Asynch_Read_Dgram_Result_Impl *implementation); - - /// Destructor. - virtual ~Result (void); - - /// The implementation class. - ACE_Asynch_Read_Dgram_Result_Impl *implementation_; - }; -private: - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Asynch_Read_Dgram &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Asynch_Read_Dgram (const ACE_Asynch_Read_Dgram &)) -}; - -// Forward declarations -class ACE_Asynch_Write_Dgram_Impl; -class ACE_Asynch_Write_Dgram_Result_Impl; - -/** - * @class ACE_Asynch_Write_Dgram - * - * @brief This class is a factory for starting off asynchronous writes - * on a UDP socket. This class forwards all methods to its - * implementation class. - * - * Once {open} is called, multiple asynchronous {writes}s can - * started using this class. An ACE_Asynch_Write_Dgram::Result - * will be passed back to the {handler} when the asynchronous - * write completes through the - * {ACE_Handler::handle_write_dgram} callback. - */ -class ACE_Export ACE_Asynch_Write_Dgram : public ACE_Asynch_Operation -{ -public: - /// A do nothing constructor. - ACE_Asynch_Write_Dgram (void); - - /// Destructor. - virtual ~ACE_Asynch_Write_Dgram (void); - - /** - * Initializes the factory with information which will be used with - * each asynchronous call. If ({handle} == ACE_INVALID_HANDLE), - * {ACE_Handler::handle} will be called on the {handler} to get the - * correct handle. - */ - int open (ACE_Handler &handler, - ACE_HANDLE handle = ACE_INVALID_HANDLE, - const void *completion_key = 0, - ACE_Proactor *proactor = 0); - - /** This starts off an asynchronous send. Upto - * {message_block->total_length()} will be sent. {message_block}'s - * {rd_ptr} will be updated to reflect the sent bytes if the send operation - * is successfully completed. - * Return code of 1 means immediate success and {number_of_bytes_sent} - * is updated to number of bytes sent. The {ACE_Handler::handle_write_dgram} - * method will still be called. Return code of 0 means the IO will - * complete proactively. Return code of -1 means there was an error, use - * errno to get the error code. - * - * Scatter/gather is supported on WIN32 by using the {message_block->cont()} - * method. Up to ACE_IOV_MAX {message_block}'s are supported. Upto - * {message_block->length()} bytes will be sent from each {message block} - * for a total of {message_block->total_length()} bytes. All - * {message_block}'s {rd_ptr}'s will be updated to reflect the bytes sent - * from each {message_block}. - * - * Priority of the operation is specified by {priority}. On POSIX4-Unix, - * this is supported. Works like {nice} in Unix. Negative values are not - * allowed. 0 means priority of the operation same as the process - * priority. 1 means priority of the operation is one less than - * process. And so forth. On Win32, this argument is a no-op. - * {signal_number} is the POSIX4 real-time signal number to be used - * for the operation. {signal_number} ranges from ACE_SIGRTMIN to - * ACE_SIGRTMAX. This argument is a no-op on non-POSIX4 systems. - */ - ssize_t send (ACE_Message_Block *message_block, - size_t &number_of_bytes_sent, - int flags, - const ACE_Addr& remote_addr, - const void *act = 0, - int priority = 0, - int signal_number = ACE_SIGRTMIN); - - /// Return the underlying implementation class. - // (this should be protected...) - virtual ACE_Asynch_Operation_Impl *implementation (void) const; - -protected: - /// Implementation class that all methods will be forwarded to. - ACE_Asynch_Write_Dgram_Impl *implementation_; - -public: -/** - * @class Result - * - * @brief This is that class which will be passed back to the - * {handler} when the asynchronous write completes. This class - * forwards all the methods to the implementation class. - * - * This class has all the information necessary for the - * {handler} to uniquiely identify the completion of the - * asynchronous write. - */ - class ACE_Export Result : public ACE_Asynch_Result - { - /// The concrete implementation result classes only construct this - /// class. - friend class ACE_POSIX_Asynch_Write_Dgram_Result; - friend class ACE_WIN32_Asynch_Write_Dgram_Result; - - public: - /// The number of bytes which were requested at the start of the - /// asynchronous write. - size_t bytes_to_write (void) const; - - /// Message block which contains the sent data - ACE_Message_Block *message_block (void) const; - - /// The flags using in the write - int flags (void) const; - - /// I/O handle used for writing. - ACE_HANDLE handle (void) const; - - /// Get the implementation class. - ACE_Asynch_Write_Dgram_Result_Impl *implementation (void) const; - - protected: - /// Constructor. - Result (ACE_Asynch_Write_Dgram_Result_Impl *implementation); - - /// Destructor. - virtual ~Result (void); - - /// Implementation class. - ACE_Asynch_Write_Dgram_Result_Impl *implementation_; - }; -private: - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Asynch_Write_Dgram &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Asynch_Write_Dgram (const ACE_Asynch_Write_Dgram &)) -}; - - -/** - * @class ACE_Handler - * - * @brief This base class defines the interface for receiving the - * results of asynchronous operations. - * - * Subclasses of this class will fill in appropriate methods. - */ -class ACE_Export ACE_Handler -{ -public: - /// A do nothing constructor. - ACE_Handler (void); - - /// A do nothing constructor which allows proactor to be set to \. - ACE_Handler (ACE_Proactor *p); - - /// Virtual destruction. - virtual ~ACE_Handler (void); - - /// This method will be called when an asynchronous read completes on - /// a stream. - virtual void handle_read_stream (const ACE_Asynch_Read_Stream::Result &result); - - /// This method will be called when an asynchronous write completes - /// on a UDP socket. - virtual void handle_write_dgram (const ACE_Asynch_Write_Dgram::Result &result); - - /// This method will be called when an asynchronous read completes on - /// a UDP socket. - virtual void handle_read_dgram (const ACE_Asynch_Read_Dgram::Result &result); - - /// This method will be called when an asynchronous write completes - /// on a stream. - virtual void handle_write_stream (const ACE_Asynch_Write_Stream::Result &result); - - /// This method will be called when an asynchronous read completes on - /// a file. - virtual void handle_read_file (const ACE_Asynch_Read_File::Result &result); - - /// This method will be called when an asynchronous write completes - /// on a file. - virtual void handle_write_file (const ACE_Asynch_Write_File::Result &result); - - /// This method will be called when an asynchronous accept completes. - virtual void handle_accept (const ACE_Asynch_Accept::Result &result); - - /// This method will be called when an asynchronous connect completes. - virtual void handle_connect (const ACE_Asynch_Connect::Result &result); - - /// This method will be called when an asynchronous transmit file - /// completes. - virtual void handle_transmit_file (const ACE_Asynch_Transmit_File::Result &result); - - /// Called when timer expires. {tv} was the requested time value and - /// {act} is the ACT passed when scheduling the timer. - virtual void handle_time_out (const ACE_Time_Value &tv, - const void *act = 0); - - /** - * This is method works with the {run_event_loop} of the - * ACE_Proactor. A special {Wake_Up_Completion} is used to wake up - * all the threads that are blocking for completions. - */ - virtual void handle_wakeup (void); - - /// Get the proactor associated with this handler. - ACE_Proactor *proactor (void); - - /// Set the proactor. - void proactor (ACE_Proactor *p); - - /** - * Get the I/O handle used by this {handler}. This method will be - * called by the ACE_Asynch_* classes when an ACE_INVALID_HANDLE is - * passed to {open}. - */ - virtual ACE_HANDLE handle (void) const; - - /// Set the ACE_HANDLE value for this Handler. - virtual void handle (ACE_HANDLE); - - /** - * @class Proxy - * - * @brief The Proxy class acts as a proxy for dispatch of completions - * to operations issued for the associated handler. It allows the handler - * to be deleted while operations are outstanding. The proxy must be used - * to get the ACE_Handler pointer for dispatching, and if it's 0, the - * handler is no longer valid and the result should not be dispatched. - */ - class ACE_Export Proxy - { - public: - Proxy (ACE_Handler *handler) : handler_ (handler) {}; - void reset (void) { this->handler_ = 0; }; - ACE_Handler *handler (void) { return this->handler_; }; - private: - ACE_Handler *handler_; - }; - typedef ACE_Refcounted_Auto_Ptr - Proxy_Ptr; - - Proxy_Ptr &proxy (void); - -protected: - /// The proactor associated with this handler. - ACE_Proactor *proactor_; - - /// The ACE_HANDLE in use with this handler. - ACE_HANDLE handle_; - - /// Refers to proxy for this handler. - ACE_Refcounted_Auto_Ptr proxy_; - -private: - ACE_UNIMPLEMENTED_FUNC (ACE_Handler (const ACE_Handler &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Handler operator= (const ACE_Handler &)) -}; - -// Forward declarations -class ACE_INET_Addr; - -// Forward declarations -template -class ACE_Asynch_Acceptor; - -/** - * @class ACE_Service_Handler - * - * @brief This base class defines the interface for the - * ACE_Asynch_Acceptor to call into when new connection are - * accepted. - * - * Subclasses of this class will fill in appropriate methods to - * define application specific behavior. - */ -class ACE_Export ACE_Service_Handler : public ACE_Handler -{ - /// The Acceptor is the factory and therefore should have special - /// privileges. - friend class ACE_Asynch_Acceptor; - -public: - /// A do nothing constructor. - ACE_Service_Handler (void); - - /// Virtual destruction. - virtual ~ACE_Service_Handler (void); - - /** - * {open} is called by ACE_Asynch_Acceptor to initialize a new - * instance of ACE_Service_Handler that has been created after the - * new connection is accepted. The handle for the new connection is - * passed along with the initial data that may have shown up. - */ - virtual void open (ACE_HANDLE new_handle, - ACE_Message_Block &message_block); - - // protected: - // This should be corrected after the correct semantics of the - // friend has been figured out. - - /// Called by ACE_Asynch_Acceptor to pass the addresses of the new - /// connections. - virtual void addresses (const ACE_INET_Addr &remote_address, - const ACE_INET_Addr &local_address); - - /// Called by ACE_Asynch_Acceptor to pass the act. - virtual void act (const void *); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_WIN32 || ACE_HAS_AIO_CALLS*/ -#include /**/ "ace/post.h" -#endif /* ACE_ASYNCH_IO_H */ diff --git a/deps/acelite/ace/Asynch_IO_Impl.cpp b/deps/acelite/ace/Asynch_IO_Impl.cpp deleted file mode 100644 index 1f25a1ee7..000000000 --- a/deps/acelite/ace/Asynch_IO_Impl.cpp +++ /dev/null @@ -1,115 +0,0 @@ -#include "ace/Asynch_IO_Impl.h" - -#if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS) -// This only works on Win32 platforms and on Unix platforms supporting -// aio calls. - -#if !defined (__ACE_INLINE__) -#include "ace/Asynch_IO_Impl.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Asynch_Result_Impl::~ACE_Asynch_Result_Impl (void) -{ -} - -ACE_Asynch_Operation_Impl::~ACE_Asynch_Operation_Impl (void) -{ -} - -ACE_Asynch_Read_Stream_Impl::~ACE_Asynch_Read_Stream_Impl (void) -{ -} - -ACE_Asynch_Read_Stream_Result_Impl::~ACE_Asynch_Read_Stream_Result_Impl (void) -{ -} - -ACE_Asynch_Write_Stream_Impl::~ACE_Asynch_Write_Stream_Impl (void) -{ -} - -ACE_Asynch_Write_Stream_Result_Impl::~ACE_Asynch_Write_Stream_Result_Impl (void) -{ -} - -ACE_Asynch_Read_File_Impl::~ACE_Asynch_Read_File_Impl (void) -{ -} - -ACE_Asynch_Write_File_Impl::~ACE_Asynch_Write_File_Impl (void) -{ -} - -ACE_Asynch_Read_File_Result_Impl::~ACE_Asynch_Read_File_Result_Impl (void) -{ -} - -ACE_Asynch_Write_File_Result_Impl::~ACE_Asynch_Write_File_Result_Impl (void) -{ -} - -ACE_Asynch_Accept_Result_Impl::~ACE_Asynch_Accept_Result_Impl (void) -{ -} - -ACE_Asynch_Connect_Result_Impl::~ACE_Asynch_Connect_Result_Impl (void) -{ -} - -ACE_Asynch_Accept_Impl::~ACE_Asynch_Accept_Impl (void) -{ -} - -ACE_Asynch_Connect_Impl::~ACE_Asynch_Connect_Impl (void) -{ -} - -ACE_Asynch_Transmit_File_Impl::~ACE_Asynch_Transmit_File_Impl (void) -{ -} - -ACE_Asynch_Transmit_File_Result_Impl::~ACE_Asynch_Transmit_File_Result_Impl (void) -{ -} - -ACE_Asynch_Read_Dgram_Impl::~ACE_Asynch_Read_Dgram_Impl (void) -{ -} - -ACE_Asynch_Read_Dgram_Impl::ACE_Asynch_Read_Dgram_Impl (void) -{ -} - -ACE_Asynch_Write_Dgram_Impl::~ACE_Asynch_Write_Dgram_Impl (void) -{ -} - -ACE_Asynch_Write_Dgram_Impl::ACE_Asynch_Write_Dgram_Impl (void) -{ -} - -//*********************************************** - -ACE_Asynch_Read_Dgram_Result_Impl::~ACE_Asynch_Read_Dgram_Result_Impl (void) -{ -} - -ACE_Asynch_Read_Dgram_Result_Impl::ACE_Asynch_Read_Dgram_Result_Impl (void) -{ -} - -//*********************************************** - -ACE_Asynch_Write_Dgram_Result_Impl::~ACE_Asynch_Write_Dgram_Result_Impl (void) -{ -} - -ACE_Asynch_Write_Dgram_Result_Impl::ACE_Asynch_Write_Dgram_Result_Impl (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_WIN32_OVERLAPPED_IO || ACE_HAS_AIO_CALLS */ diff --git a/deps/acelite/ace/Asynch_IO_Impl.h b/deps/acelite/ace/Asynch_IO_Impl.h deleted file mode 100644 index a4ec996df..000000000 --- a/deps/acelite/ace/Asynch_IO_Impl.h +++ /dev/null @@ -1,793 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Asynch_IO_Impl.h - * - * This class contains asbtract base classes for all the concrete - * implementation classes for the various asynchronous operations - * that are used with the Praoctor. - * - * @author Irfan Pyarali (irfan@cs.wustl.edu) - * @author Tim Harrison (harrison@cs.wustl.edu) - * @author Alexander Babu Arulanthu - * @author Roger Tragin - * @author Alexander Libman - */ -//============================================================================= - -#ifndef ACE_ASYNCH_IO_IMPL_H -#define ACE_ASYNCH_IO_IMPL_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_WIN32_OVERLAPPED_IO) || defined (ACE_HAS_AIO_CALLS) -// This only works on Win32 platforms and on Unix platforms supporting -// aio calls. - -#include "ace/Asynch_IO.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward declaration. -class ACE_Proactor_Impl; - -/** - * @class ACE_Asynch_Result_Impl - * - * @brief Abstract base class for the all the classes that provide - * concrete implementations for ACE_Asynch_Result. - */ -class ACE_Export ACE_Asynch_Result_Impl -{ -public: - virtual ~ACE_Asynch_Result_Impl (void); - - /// Number of bytes transferred by the operation. - virtual size_t bytes_transferred (void) const = 0; - - /// ACT associated with the operation. - virtual const void *act (void) const = 0; - - /// Did the operation succeed? - virtual int success (void) const = 0; - - /// This ACT is not the same as the ACT associated with the - /// asynchronous operation. - virtual const void *completion_key (void) const = 0; - - /// Error value if the operation fail. - virtual u_long error (void) const = 0; - - /// Event associated with the OVERLAPPED structure. - virtual ACE_HANDLE event (void) const = 0; - - /// This really make sense only when doing file I/O. - virtual u_long offset (void) const = 0; - virtual u_long offset_high (void) const = 0; - - /// Priority of the operation. - virtual int priority (void) const = 0; - - /** - * POSIX4 real-time signal number to be used for the - * operation. signal_number ranges from SIGRTMIN to SIGRTMAX. By - * default, SIGRTMIN is used to issue calls. This is a no-op - * on non-POSIX4 systems and returns 0. - */ - virtual int signal_number (void) const = 0; - - // protected: - // - // These two should really be protected. But sometimes it - // simplifies code to be able to "fake" a result. Use carefully. - /// This is called when the asynchronous operation completes. - virtual void complete (size_t bytes_transferred, - int success, - const void *completion_key, - u_long error = 0) = 0; - - /// Post @c this to the Proactor's completion port. - virtual int post_completion (ACE_Proactor_Impl *proactor) = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Result_Impl (void); -}; - -/** - * @class ACE_Asynch_Operation_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Operation. - */ -class ACE_Export ACE_Asynch_Operation_Impl -{ -public: - virtual ~ACE_Asynch_Operation_Impl (void); - - /** - * Initializes the factory with information which will be used with - * each asynchronous call. If @a handle == ACE_INVALID_HANDLE, - * ACE_Handler::handle() will be called on the proxied handler to get the - * correct handle. - */ - virtual int open (const ACE_Handler::Proxy_Ptr &handler_proxy, - ACE_HANDLE handle, - const void *completion_key, - ACE_Proactor *proactor) = 0; - - /** - * This cancels all pending accepts operations that were issued by - * the calling thread. The function does not cancel asynchronous - * operations issued by other threads. - */ - virtual int cancel (void) = 0; - - // = Access methods. - - /// Return the underlying proactor. - virtual ACE_Proactor* proactor (void) const = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Operation_Impl (void); -}; - -/** - * @class ACE_Asynch_Read_Stream_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Read_Stream - */ -class ACE_Export ACE_Asynch_Read_Stream_Impl : public virtual ACE_Asynch_Operation_Impl -{ -public: - virtual ~ACE_Asynch_Read_Stream_Impl (void); - - /// This starts off an asynchronous read. Upto @a bytes_to_read will - /// be read and stored in the @a message_block. - virtual int read (ACE_Message_Block &message_block, - size_t bytes_to_read, - const void *act, - int priority, - int signal_number) = 0; - -#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) - /** - * Same as above but with scatter support, through chaining of composite - * message blocks using the continuation field. - */ - virtual int readv (ACE_Message_Block &message_block, - size_t bytes_to_read, - const void *act, - int priority, - int signal_number) = 0; -#endif /* (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) */ - -protected: - /// Do-nothing constructor. - ACE_Asynch_Read_Stream_Impl (void); -}; - -/** - * @class ACE_Asynch_Read_Stream_Result_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Read_Stream::Result class. - */ -class ACE_Export ACE_Asynch_Read_Stream_Result_Impl : public virtual ACE_Asynch_Result_Impl -{ -public: - virtual ~ACE_Asynch_Read_Stream_Result_Impl (void); - - /// The number of bytes which were requested at the start of the - /// asynchronous read. - virtual size_t bytes_to_read (void) const = 0; - - /// Message block which contains the read data. - virtual ACE_Message_Block &message_block (void) const = 0; - - /// I/O handle used for reading. - virtual ACE_HANDLE handle (void) const = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Read_Stream_Result_Impl (void); -}; - -/** - * @class ACE_Asynch_Write_Stream_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Write_Stream class. - */ -class ACE_Export ACE_Asynch_Write_Stream_Impl : public virtual ACE_Asynch_Operation_Impl -{ -public: - virtual ~ACE_Asynch_Write_Stream_Impl (void); - - /// This starts off an asynchronous write. Upto @a bytes_to_write - /// will be written from the @a message_block. - virtual int write (ACE_Message_Block &message_block, - size_t bytes_to_write, - const void *act, - int priority, - int signal_number) = 0; - -#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) - /** - * Same as above but with gather support, through chaining of composite - * message blocks using the continuation field. - */ - virtual int writev (ACE_Message_Block &message_block, - size_t bytes_to_write, - const void *act, - int priority, - int signal_number) = 0; -#endif /* (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) */ - -protected: - /// Do-nothing constructor. - ACE_Asynch_Write_Stream_Impl (void); -}; - -/** - * @class ACE_Asynch_Write_Stream_Result_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Write_Stream::Result. - */ -class ACE_Export ACE_Asynch_Write_Stream_Result_Impl : public virtual ACE_Asynch_Result_Impl -{ -public: - virtual ~ACE_Asynch_Write_Stream_Result_Impl (void); - - /// The number of bytes which were requested at the start of the - /// asynchronous write. - virtual size_t bytes_to_write (void) const = 0; - - /// Message block that contains the data to be written. - virtual ACE_Message_Block &message_block (void) const = 0; - - /// I/O handle used for writing. - virtual ACE_HANDLE handle (void) const = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Write_Stream_Result_Impl (void); -}; - -/** - * @class ACE_Asynch_Read_File_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Read_File::Result. - */ -class ACE_Export ACE_Asynch_Read_File_Impl : public virtual ACE_Asynch_Read_Stream_Impl -{ -public: - virtual ~ACE_Asynch_Read_File_Impl (void); - - /** - * This starts off an asynchronous read. Upto @a bytes_to_read will - * be read and stored in the @a message_block. The read will start - * at @a offset from the beginning of the file. - */ - virtual int read (ACE_Message_Block &message_block, - size_t bytes_to_read, - u_long offset, - u_long offset_high, - const void *act, - int priority, - int signal_number) = 0; - -#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) - /** - * Same as above but with scatter support, through chaining of composite - * message blocks using the continuation field. - * @note In win32 Each data block payload must be at least the size of a system - * memory page and must be aligned on a system memory page size boundary - */ - virtual int readv (ACE_Message_Block &message_block, - size_t bytes_to_read, - u_long offset, - u_long offset_high, - const void *act, - int priority, - int signal_number) = 0; -#endif /* (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) */ - - /// This starts off an asynchronous read. Upto @a bytes_to_read will - /// be read and stored in the @a message_block. - virtual int read (ACE_Message_Block &message_block, - size_t bytes_to_read, - const void *act, - int priority, - int signal_number) = 0; - -#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) - /** - * Same as above but with scatter support, through chaining of composite - * message blocks using the continuation field. - */ - virtual int readv (ACE_Message_Block &message_block, - size_t bytes_to_read, - const void *act, - int priority, - int signal_number) = 0; -#endif /* (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) */ - -protected: - /// Do-nothing constructor. - ACE_Asynch_Read_File_Impl (void); -}; - -/** - * @class ACE_Asynch_Read_File_Result_Impl - * - * @brief This is the abstract base class for all the concrete - * implementation classes for ACE_Asynch_Read_File::Result. - */ -class ACE_Export ACE_Asynch_Read_File_Result_Impl : public virtual ACE_Asynch_Read_Stream_Result_Impl -{ -public: - /// Destructor. - virtual ~ACE_Asynch_Read_File_Result_Impl (void); - -protected: - /// Do-nothing constructor. - ACE_Asynch_Read_File_Result_Impl (void); -}; - -/** - * @class ACE_Asynch_Write_File_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Write_File. - */ -class ACE_Export ACE_Asynch_Write_File_Impl : public virtual ACE_Asynch_Write_Stream_Impl -{ -public: - virtual ~ACE_Asynch_Write_File_Impl (void); - - /** - * This starts off an asynchronous write. Upto @a bytes_to_write - * will be write and stored in the @a message_block. The write will - * start at @a offset from the beginning of the file. - */ - virtual int write (ACE_Message_Block &message_block, - size_t bytes_to_write, - u_long offset, - u_long offset_high, - const void *act, - int priority, - int signal_number) = 0; - -#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) - /** - * Same as above but with gather support, through chaining of composite - * message blocks using the continuation field. - * @note In win32 Each data block payload must be at least the size of a system - * memory page and must be aligned on a system memory page size boundary - */ - virtual int writev (ACE_Message_Block &message_block, - size_t bytes_to_write, - u_long offset, - u_long offset_high, - const void *act, - int priority, - int signal_number) = 0; -#endif /* (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) */ - - /// This starts off an asynchronous write. Upto @a bytes_to_write - /// will be written from the @a message_block. - virtual int write (ACE_Message_Block &message_block, - size_t bytes_to_write, - const void *act, - int priority, - int signal_number) = 0; - -#if (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) - /** - * Same as above but with gather support, through chaining of composite - * message blocks using the continuation field. - */ - virtual int writev (ACE_Message_Block &message_block, - size_t bytes_to_write, - const void *act, - int priority, - int signal_number) = 0; -#endif /* (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE)) */ - -protected: - /// Do-nothing constructor. - ACE_Asynch_Write_File_Impl (void); -}; - -/** - * @class ACE_Asynch_Write_File_Result_Impl - * - * @brief This is the abstract base class for all the concrete - * implementation classes that provide different implementations - * for the ACE_Asynch_Write_File::Result. - */ -class ACE_Export ACE_Asynch_Write_File_Result_Impl : public virtual ACE_Asynch_Write_Stream_Result_Impl -{ -public: - virtual ~ACE_Asynch_Write_File_Result_Impl (void); - -protected: - /// Do-nothing constructor. - ACE_Asynch_Write_File_Result_Impl (void); -}; - -/** - * @class ACE_Asynch_Accept_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Accept. - */ -class ACE_Export ACE_Asynch_Accept_Impl : public virtual ACE_Asynch_Operation_Impl -{ -public: - virtual ~ACE_Asynch_Accept_Impl (void); - - /** - * This starts off an asynchronous accept. The asynchronous accept - * call also allows any initial data to be returned to the - * . Upto @a bytes_to_read will be read and stored in the - * @a message_block. The @a accept_handle will be used for the - * call. If (@a accept_handle == INVALID_HANDLE), a new - * handle will be created. - * - * @a message_block must be specified. This is because the address of - * the new connection is placed at the end of this buffer. - */ - virtual int accept (ACE_Message_Block &message_block, - size_t bytes_to_read, - ACE_HANDLE accept_handle, - const void *act, - int priority, - int signal_number, - int addr_family) = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Accept_Impl (void); -}; - -/** - * @class ACE_Asynch_Accept_Result_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Accept. - */ -class ACE_Export ACE_Asynch_Accept_Result_Impl : public virtual ACE_Asynch_Result_Impl -{ -public: - virtual ~ACE_Asynch_Accept_Result_Impl (void); - - /// The number of bytes which were requested at the start of the - /// asynchronous accept. - virtual size_t bytes_to_read (void) const = 0; - - /// Message block which contains the read data. - virtual ACE_Message_Block &message_block (void) const = 0; - - /// I/O handle used for accepting new connections. - virtual ACE_HANDLE listen_handle (void) const = 0; - - /// I/O handle for the new connection. - virtual ACE_HANDLE accept_handle (void) const = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Accept_Result_Impl (void); -}; - - -/** - * @class ACE_Asynch_Connect_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Connect. - */ -class ACE_Export ACE_Asynch_Connect_Impl : public virtual ACE_Asynch_Operation_Impl -{ -public: - virtual ~ACE_Asynch_Connect_Impl (void); - - /** - * This starts off an asynchronous connect - */ - virtual int connect (ACE_HANDLE connect_handle, - const ACE_Addr & remote_sap, - const ACE_Addr & local_sap, - int reuse_addr, - const void *act, - int priority, - int signal_number) = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Connect_Impl (void); -}; - -/** - * @class ACE_Asynch_Connect_Result_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Connect. - */ -class ACE_Export ACE_Asynch_Connect_Result_Impl : public virtual ACE_Asynch_Result_Impl -{ -public: - virtual ~ACE_Asynch_Connect_Result_Impl (void); - - /// I/O handle for the connection. - virtual ACE_HANDLE connect_handle (void) const = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Connect_Result_Impl (void); -}; - - -/** - * @class ACE_Asynch_Transmit_File_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Transmit_File. - */ -class ACE_Asynch_Transmit_File_Impl : public virtual ACE_Asynch_Operation_Impl -{ -public: - virtual ~ACE_Asynch_Transmit_File_Impl (void); - - /// This starts off an asynchronous transmit file. - virtual int transmit_file (ACE_HANDLE file, - ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer, - size_t bytes_to_write, - u_long offset, - u_long offset_high, - size_t bytes_per_send, - u_long flags, - const void *act, - int priority, - int signal_number) = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Transmit_File_Impl (void); -}; - -/** - * @class ACE_Asynch_Transmit_File_Result_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Transmit_File::Result. - */ -class ACE_Export ACE_Asynch_Transmit_File_Result_Impl : public virtual ACE_Asynch_Result_Impl -{ -public: - virtual ~ACE_Asynch_Transmit_File_Result_Impl (void); - - /// Socket used for transmitting the file. - virtual ACE_HANDLE socket (void) const = 0; - - /// File from which the data is read. - virtual ACE_HANDLE file (void) const = 0; - - /// Header and trailer data associated with this transmit file. - virtual ACE_Asynch_Transmit_File::Header_And_Trailer *header_and_trailer (void) const = 0; - - /// The number of bytes which were requested at the start of the - /// asynchronous transmit file. - virtual size_t bytes_to_write (void) const = 0; - - /// Number of bytes per send requested at the start of the transmit - /// file. - virtual size_t bytes_per_send (void) const = 0; - - /// Flags which were passed into transmit file. - virtual u_long flags (void) const = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Transmit_File_Result_Impl (void); -}; - - -/** - * @class ACE_Asynch_Read_Dgram_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Read_Dgram - */ -class ACE_Export ACE_Asynch_Read_Dgram_Impl : public virtual ACE_Asynch_Operation_Impl -{ -public: - virtual ~ACE_Asynch_Read_Dgram_Impl (void); - - /** This starts off an asynchronous read. Upto - * total_size()> will be read and stored in the - * @a message_block. @a message_block's will be updated to reflect - * the added bytes if the read operation is successful completed. - * Return code of 1 means immediate success and - * will contain number of bytes read. The - * method will still be called. Return code of 0 means the IO will - * complete proactively. Return code of -1 means there was an error, use - * errno to get the error code. - * - * Scatter/gather is supported on WIN32 by using the cont()> - * method. Up to ACE_IOV_MAX @a message_block's are supported. Upto - * size()> bytes will be read into each for - * a total of total_size()> bytes. All @a message_block's - * 's will be updated to reflect the added bytes for each - * @a message_block - * - * Priority of the operation is specified by @a priority. On POSIX4-Unix, - * this is supported. Works like in Unix. Negative values are not - * allowed. 0 means priority of the operation same as the process - * priority. 1 means priority of the operation is one less than - * process. And so forth. On Win32, @a priority is a no-op. - * @a signal_number is the POSIX4 real-time signal number to be used - * for the operation. @a signal_number ranges from ACE_SIGRTMIN to - * ACE_SIGRTMAX. This argument is a no-op on non-POSIX4 systems. - */ - virtual ssize_t recv (ACE_Message_Block *message_block, - size_t &number_of_bytes_recvd, - int flags, - int protocol_family, - const void *act, - int priority, - int signal_number) = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Read_Dgram_Impl (void); -}; - -/** - * @class ACE_Asynch_Read_Dgram_Result_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Read_Dgram::Result class. - */ -class ACE_Export ACE_Asynch_Read_Dgram_Result_Impl : public virtual ACE_Asynch_Result_Impl -{ -public: - virtual ~ACE_Asynch_Read_Dgram_Result_Impl (void); - - /// Message block which contains the read data - virtual ACE_Message_Block *message_block (void) const = 0; - - /// The number of bytes which were requested at the start of the - /// asynchronous read. - virtual size_t bytes_to_read (void) const = 0; - - /// The address of where the packet came from - virtual int remote_address (ACE_Addr& addr) const = 0; - - /// The flags used in the read - virtual int flags (void) const = 0; - - /// I/O handle used for reading. - virtual ACE_HANDLE handle (void) const = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Read_Dgram_Result_Impl (void); -}; - -/** - * @class ACE_Asynch_Write_Dgram_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Write_Dgram class. - */ -class ACE_Export ACE_Asynch_Write_Dgram_Impl : public virtual ACE_Asynch_Operation_Impl -{ -public: - virtual ~ACE_Asynch_Write_Dgram_Impl (void); - - /** This starts off an asynchronous send. Upto - * total_length()> will be sent. @a message_block's - * will be updated to reflect the sent bytes if the send operation - * is successful completed. - * Return code of 1 means immediate success and - * is updated to number of bytes sent. The - * method will still be called. Return code of 0 means the IO will - * complete proactively. Return code of -1 means there was an error, use - * errno to get the error code. - * - * Scatter/gather is supported on WIN32 by using the cont()> - * method. Up to ACE_IOV_MAX @a message_block's are supported. Upto - * length()> bytes will be sent from each - * for a total of total_length()> bytes. All - * @a message_block's 's will be updated to reflect the bytes sent - * from each @a message_block. - * - * Priority of the operation is specified by @a priority. On POSIX4-Unix, - * this is supported. Works like in Unix. Negative values are not - * allowed. 0 means priority of the operation same as the process - * priority. 1 means priority of the operation is one less than - * process. And so forth. On Win32, this argument is a no-op. - * @a signal_number is the POSIX4 real-time signal number to be used - * for the operation. @a signal_number ranges from ACE_SIGRTMIN to - * ACE_SIGRTMAX. This argument is a no-op on non-POSIX4 systems. - */ - virtual ssize_t send (ACE_Message_Block *message_block, - size_t &number_of_bytes_sent, - int flags, - const ACE_Addr &addr, - const void *act, - int priority, - int signal_number) = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Write_Dgram_Impl (void); -}; - -/** - * @class ACE_Asynch_Write_Dgram_Result_Impl - * - * @brief Abstract base class for all the concrete implementation - * classes that provide different implementations for the - * ACE_Asynch_Write_Dgram::Result class. - */ -class ACE_Export ACE_Asynch_Write_Dgram_Result_Impl : public virtual ACE_Asynch_Result_Impl -{ -public: - virtual ~ACE_Asynch_Write_Dgram_Result_Impl (void); - - /// The number of bytes which were requested at the start of the - /// asynchronous write. - virtual size_t bytes_to_write (void) const = 0; - - /// Message block which contains the sent data - virtual ACE_Message_Block *message_block (void) const = 0; - - /// The flags using in the write - virtual int flags (void) const = 0; - - /// I/O handle used for writing. - virtual ACE_HANDLE handle (void) const = 0; - -protected: - /// Do-nothing constructor. - ACE_Asynch_Write_Dgram_Result_Impl (void); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Asynch_IO_Impl.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* ACE_HAS_WIN32_OVERLAPPED_IO || ACE_HAS_AIO_CALLS */ -#include /**/ "ace/post.h" -#endif /* ACE_ASYNCH_IO_IMPL_H */ diff --git a/deps/acelite/ace/Asynch_IO_Impl.inl b/deps/acelite/ace/Asynch_IO_Impl.inl deleted file mode 100644 index e6fce33b3..000000000 --- a/deps/acelite/ace/Asynch_IO_Impl.inl +++ /dev/null @@ -1,103 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Asynch_Result_Impl::ACE_Asynch_Result_Impl (void) -{ -} - -ACE_INLINE -ACE_Asynch_Operation_Impl::ACE_Asynch_Operation_Impl (void) -{ -} - -ACE_INLINE -ACE_Asynch_Read_Stream_Impl::ACE_Asynch_Read_Stream_Impl (void) - : ACE_Asynch_Operation_Impl () -{ -} - -ACE_INLINE -ACE_Asynch_Read_Stream_Result_Impl::ACE_Asynch_Read_Stream_Result_Impl (void) - : ACE_Asynch_Result_Impl () -{ -} - -ACE_INLINE -ACE_Asynch_Write_Stream_Impl::ACE_Asynch_Write_Stream_Impl (void) - : ACE_Asynch_Operation_Impl () -{ -} - -ACE_INLINE -ACE_Asynch_Write_Stream_Result_Impl::ACE_Asynch_Write_Stream_Result_Impl (void) - : ACE_Asynch_Result_Impl () -{ -} - -ACE_INLINE -ACE_Asynch_Read_File_Impl::ACE_Asynch_Read_File_Impl (void) - : ACE_Asynch_Operation_Impl (), - ACE_Asynch_Read_Stream_Impl () -{ -} - -ACE_INLINE -ACE_Asynch_Read_File_Result_Impl::ACE_Asynch_Read_File_Result_Impl (void) - : ACE_Asynch_Result_Impl (), - ACE_Asynch_Read_Stream_Result_Impl () -{ -} - -ACE_INLINE -ACE_Asynch_Write_File_Impl::ACE_Asynch_Write_File_Impl (void) - : ACE_Asynch_Operation_Impl (), - ACE_Asynch_Write_Stream_Impl () -{ -} - -ACE_INLINE -ACE_Asynch_Write_File_Result_Impl::ACE_Asynch_Write_File_Result_Impl (void) - : ACE_Asynch_Result_Impl (), - ACE_Asynch_Write_Stream_Result_Impl () -{ -} - -ACE_INLINE -ACE_Asynch_Accept_Impl::ACE_Asynch_Accept_Impl (void) - : ACE_Asynch_Operation_Impl () -{ -} - -ACE_INLINE -ACE_Asynch_Accept_Result_Impl::ACE_Asynch_Accept_Result_Impl (void) - : ACE_Asynch_Result_Impl () -{ -} - -ACE_INLINE -ACE_Asynch_Connect_Impl::ACE_Asynch_Connect_Impl (void) - : ACE_Asynch_Operation_Impl () -{ -} - -ACE_INLINE -ACE_Asynch_Connect_Result_Impl::ACE_Asynch_Connect_Result_Impl (void) - : ACE_Asynch_Result_Impl () -{ -} - - -ACE_INLINE -ACE_Asynch_Transmit_File_Impl::ACE_Asynch_Transmit_File_Impl (void) - : ACE_Asynch_Operation_Impl () -{ -} - -ACE_INLINE -ACE_Asynch_Transmit_File_Result_Impl::ACE_Asynch_Transmit_File_Result_Impl (void) - : ACE_Asynch_Result_Impl () -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Asynch_Pseudo_Task.cpp b/deps/acelite/ace/Asynch_Pseudo_Task.cpp deleted file mode 100644 index 0b6a14b60..000000000 --- a/deps/acelite/ace/Asynch_Pseudo_Task.cpp +++ /dev/null @@ -1,126 +0,0 @@ -#include "ace/Asynch_Pseudo_Task.h" - -#include "ace/OS_NS_errno.h" -#include "ace/OS_NS_signal.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Asynch_Pseudo_Task::ACE_Asynch_Pseudo_Task () - : select_reactor_ (), // should be initialized before reactor_ - reactor_ (&select_reactor_, 0) // don't delete implementation -{ -} - -ACE_Asynch_Pseudo_Task::~ACE_Asynch_Pseudo_Task () -{ - this->stop (); -} - -int -ACE_Asynch_Pseudo_Task::start (void) -{ - if (this->reactor_.initialized () == 0) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%N:%l:%p\n"), - ACE_TEXT ("start reactor is not initialized")), - -1); - - return this->activate () == -1 ? -1 : 0; // If started, return 0 -} - -int -ACE_Asynch_Pseudo_Task::stop (void) -{ - if (this->thr_count () == 0) // already stopped - return 0; - - if (this->reactor_.end_reactor_event_loop () == -1) - return -1; - - this->wait (); - this->reactor_.close (); - return 0; -} - -int -ACE_Asynch_Pseudo_Task::svc (void) -{ -#if !defined (ACE_WIN32) - - sigset_t RT_signals; - - sigemptyset (&RT_signals); - for (int si = ACE_SIGRTMIN; si <= ACE_SIGRTMAX; si++) - sigaddset (&RT_signals, si); - - if (ACE_OS::pthread_sigmask (SIG_BLOCK, &RT_signals, 0) != 0) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("Error:(%P | %t):%p\n"), - ACE_TEXT ("pthread_sigmask"))); -#endif - - reactor_.owner (ACE_Thread::self ()); - reactor_.run_reactor_event_loop (); - - return 0; -} - - - -int -ACE_Asynch_Pseudo_Task::register_io_handler (ACE_HANDLE handle, - ACE_Event_Handler *handler, - ACE_Reactor_Mask mask, - int flg_suspend) -{ - // Register the handler with the reactor. - if (-1 == this->reactor_.register_handler (handle, handler, mask)) - return -1; - - if (flg_suspend == 0) - return 0; - - // Suspend the handle now. Enable only when the accept is issued - // by the application. - if (this->reactor_.suspend_handler (handle) == -1) - { - ACELIB_ERROR - ((LM_ERROR, - ACE_TEXT ("%N:%l:%p\n"), - ACE_TEXT ("register_io_handler (suspended)"))); - this->reactor_.remove_handler (handle, ACE_Event_Handler::ALL_EVENTS_MASK - | ACE_Event_Handler::DONT_CALL); - return -1; - } - - return 0; -} - -int -ACE_Asynch_Pseudo_Task::remove_io_handler (ACE_HANDLE handle) -{ - return this->reactor_.remove_handler (handle, - ACE_Event_Handler::ALL_EVENTS_MASK - | ACE_Event_Handler::DONT_CALL); -} - -int -ACE_Asynch_Pseudo_Task::remove_io_handler (ACE_Handle_Set &set) -{ - return this->reactor_.remove_handler (set, ACE_Event_Handler::ALL_EVENTS_MASK - | ACE_Event_Handler::DONT_CALL); -} - -int -ACE_Asynch_Pseudo_Task::suspend_io_handler (ACE_HANDLE handle) -{ - return this->reactor_.suspend_handler (handle); -} - -int -ACE_Asynch_Pseudo_Task::resume_io_handler (ACE_HANDLE handle) -{ - return this->reactor_.resume_handler (handle); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Asynch_Pseudo_Task.h b/deps/acelite/ace/Asynch_Pseudo_Task.h deleted file mode 100644 index 4337361fe..000000000 --- a/deps/acelite/ace/Asynch_Pseudo_Task.h +++ /dev/null @@ -1,70 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Asynch_Pseudo_Task.h - * - * @author Alexander Libman - */ -//============================================================================= - -#ifndef ACE_ASYNCH_PSEUDO_TASK_H -#define ACE_ASYNCH_PSEUDO_TASK_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Reactor.h" -#include "ace/Select_Reactor.h" -#include "ace/Task.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/* - * Specialization hook to replace the Reactor with the - * concrete Reactor implementation, e.g., select_st, - * select_mt etc. - */ -//@@ REACTOR_SPL_INCLUDE_FORWARD_DECL_ADD_HOOK - -/** - * @class ACE_Asynch_Pseudo_Task - */ -class ACE_Export ACE_Asynch_Pseudo_Task : public ACE_Task -{ -public: - ACE_Asynch_Pseudo_Task(); - virtual ~ACE_Asynch_Pseudo_Task(); - - int start (void); - int stop (void); - - int register_io_handler (ACE_HANDLE handle, - ACE_Event_Handler *handler, - ACE_Reactor_Mask mask, - int flg_suspend); - - int remove_io_handler (ACE_HANDLE handle); - int remove_io_handler (ACE_Handle_Set &set); - int resume_io_handler (ACE_HANDLE handle); - int suspend_io_handler (ACE_HANDLE handle); - -protected: - virtual int svc (void); - - /// Should be initialized before reactor_ - ACE_Select_Reactor select_reactor_; - - ACE_Reactor reactor_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#endif /* ACE_ASYNCH_PSEUDO_TASK_H */ diff --git a/deps/acelite/ace/Atomic_Op.cpp b/deps/acelite/ace/Atomic_Op.cpp deleted file mode 100644 index e1075809b..000000000 --- a/deps/acelite/ace/Atomic_Op.cpp +++ /dev/null @@ -1,304 +0,0 @@ -#include "ace/Atomic_Op.h" -#include "ace/OS_NS_unistd.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Atomic_Op.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_HAS_BUILTIN_ATOMIC_OP) - -#if defined (ACE_INCLUDE_ATOMIC_OP_SPARC) -# include "ace/Atomic_Op_Sparc.h" -#endif /* ACE_INCLUDE_ATOMIC_OP_SPARC */ - -namespace { - -#if defined (_MSC_VER) -// Disable "no return value" warning, as we will be putting -// the return values directly into the EAX register. -#pragma warning (push) -#pragma warning (disable: 4035) -#endif /* _MSC_VER */ - -long -single_cpu_increment (volatile long *value) -{ -#if defined (ACE_HAS_INTEL_ASSEMBLY) - long tmp = 1; - unsigned long addr = reinterpret_cast (value); - asm( "xadd %0, (%1)" : "+r"(tmp) : "r"(addr) ); - return tmp + 1; -#elif !defined (ACE_HAS_SOLARIS_ATOMIC_LIB) && (defined (sun) || \ - (defined (__SUNPRO_CC) && (defined (__i386) || defined (__x86_64)))) - return ace_atomic_add_long ( - reinterpret_cast (value), 1); -#elif defined(__GNUC__) && defined(__PPC__) - long tmp; - asm("lwz %0,%1" : "=r" (tmp) : "m" (*value) ); - asm("addi %0,%0,1" : "+r" (tmp) ); - asm("stw %0,%1" : "+r" (tmp), "=m" (*value) ); - return tmp; -#else /* ACE_HAS_INTEL_ASSEMBLY*/ - ACE_UNUSED_ARG (value); - ACE_NOTSUP_RETURN (-1); -#endif /* ACE_HAS_INTEL_ASSEMBLY*/ -} - -long -single_cpu_decrement (volatile long *value) -{ -#if defined (ACE_HAS_INTEL_ASSEMBLY) - long tmp = -1; - unsigned long addr = reinterpret_cast (value); - asm( "xadd %0, (%1)" : "+r"(tmp) : "r"(addr) ); - return tmp - 1; -#elif !defined (ACE_HAS_SOLARIS_ATOMIC_LIB) && (defined (sun) || \ - (defined (__SUNPRO_CC) && (defined (__i386) || defined (__x86_64)))) - return ace_atomic_add_long ( - reinterpret_cast (value), -1); -#elif defined(__GNUC__) && defined(__PPC__) - long tmp; - asm("lwz %0,%1" : "=r" (tmp) : "m" (*value) ); - asm("addi %0,%0,-1" : "+r" (tmp) ); - asm("stw %0,%1" : "+r" (tmp), "=m" (*value) ); - return tmp; -#else /* ACE_HAS_INTEL_ASSEMBLY*/ - ACE_UNUSED_ARG (value); - ACE_NOTSUP_RETURN (-1); -#endif /* ACE_HAS_INTEL_ASSEMBLY*/ -} - -long -single_cpu_exchange (volatile long *value, long rhs) -{ -#if defined (ACE_HAS_INTEL_ASSEMBLY) - unsigned long addr = reinterpret_cast (value); - asm( "xchg %0, (%1)" : "+r"(rhs) : "r"(addr) ); - return rhs; -#elif !defined (ACE_HAS_SOLARIS_ATOMIC_LIB) && (defined (sun) || \ - (defined (__SUNPRO_CC) && (defined (__i386) || defined (__x86_64)))) - return ace_atomic_swap_long ( - reinterpret_cast (value), rhs); -#elif defined(__GNUC__) && defined(__PPC__) - long tmp; - asm("lwz %0,%1" : "=r" (tmp) : "m" (rhs) ); - asm("stw %0,%1" : "+r" (tmp), "=m" (*value) ); - return tmp; -#else /* ACE_HAS_INTEL_ASSEMBLY*/ - ACE_UNUSED_ARG (value); - ACE_UNUSED_ARG (rhs); - ACE_NOTSUP_RETURN (-1); -#endif /* ACE_HAS_INTEL_ASSEMBLY*/ -} - -long -single_cpu_exchange_add (volatile long *value, long rhs) -{ -#if defined (ACE_HAS_INTEL_ASSEMBLY) - unsigned long addr = reinterpret_cast (value); - asm( "xadd %0, (%1)" : "+r"(rhs) : "r"(addr) ); - return rhs; -#elif !defined (ACE_HAS_SOLARIS_ATOMIC_LIB) && (defined (sun) || \ - (defined (__SUNPRO_CC) && (defined (__i386) || defined (__x86_64)))) - return ace_atomic_swap_add_long ( - reinterpret_cast (value), rhs); -#elif defined(__GNUC__) && defined(__PPC__) - long tmp; - asm("add %0,%1,%2" : "=r" (tmp) : "r" (*value), "r" (rhs) ); - asm("stw %0,%1" : "+r" (tmp), "=m" (*value) ); - return tmp; -#elif defined (WIN32) && !defined (ACE_HAS_INTERLOCKED_EXCHANGEADD) -# if defined (_MSC_VER) - __asm - { - mov eax, rhs - mov edx, value - xadd [edx], eax - } - // Return value is already in EAX register. -# elif defined (__BORLANDC__) - _EAX = rhs; - _EDX = reinterpret_cast (value); - __emit__(0x0F, 0xC1, 0x02); // xadd [edx], eax - // Return value is already in EAX register. -# else /* _MSC_VER */ - ACE_UNUSED_ARG (value); - ACE_UNUSED_ARG (rhs); - ACE_NOTSUP_RETURN (-1); -# endif /* _MSC_VER */ -#else /* ACE_HAS_INTEL_ASSEMBLY*/ - ACE_UNUSED_ARG (value); - ACE_UNUSED_ARG (rhs); - ACE_NOTSUP_RETURN (-1); -#endif /* ACE_HAS_INTEL_ASSEMBLY*/ -} - -long -multi_cpu_increment (volatile long *value) -{ -#if defined (ACE_HAS_INTEL_ASSEMBLY) - long tmp = 1; - unsigned long addr = reinterpret_cast (value); - asm( "lock ; xadd %0, (%1)" : "+r"(tmp) : "r"(addr) ); - return tmp + 1; -#elif !defined (ACE_HAS_SOLARIS_ATOMIC_LIB) && (defined (sun) || \ - (defined (__SUNPRO_CC) && (defined (__i386) || defined (__x86_64)))) - return ace_atomic_add_long ( - reinterpret_cast (value), 1); -#else /* ACE_HAS_INTEL_ASSEMBLY*/ - ACE_UNUSED_ARG (value); - ACE_NOTSUP_RETURN (-1); -#endif /* ACE_HAS_INTEL_ASSEMBLY*/ -} - -long -multi_cpu_decrement (volatile long *value) -{ -#if defined (ACE_HAS_INTEL_ASSEMBLY) - long tmp = -1; - unsigned long addr = reinterpret_cast (value); - asm( "lock ; xadd %0, (%1)" : "+r"(tmp) : "r"(addr) ); - return tmp - 1; -#elif !defined (ACE_HAS_SOLARIS_ATOMIC_LIB) && (defined (sun) || \ - (defined (__SUNPRO_CC) && (defined (__i386) || defined (__x86_64)))) - return ace_atomic_add_long ( - reinterpret_cast (value), -1); -#else /* ACE_HAS_INTEL_ASSEMBLY*/ - ACE_UNUSED_ARG (value); - ACE_NOTSUP_RETURN (-1); -#endif /* ACE_HAS_INTEL_ASSEMBLY*/ -} - -long -multi_cpu_exchange (volatile long *value, long rhs) -{ -#if defined (ACE_HAS_INTEL_ASSEMBLY) - unsigned long addr = reinterpret_cast (value); - // The XCHG instruction automatically follows LOCK semantics - asm( "xchg %0, (%1)" : "+r"(rhs) : "r"(addr) ); - return rhs; -#elif !defined (ACE_HAS_SOLARIS_ATOMIC_LIB) && (defined (sun) || \ - (defined (__SUNPRO_CC) && (defined (__i386) || defined (__x86_64)))) - return ace_atomic_swap_long ( - reinterpret_cast (value), rhs); -#else /* ACE_HAS_INTEL_ASSEMBLY*/ - ACE_UNUSED_ARG (value); - ACE_UNUSED_ARG (rhs); - ACE_NOTSUP_RETURN (-1); -#endif /* ACE_HAS_INTEL_ASSEMBLY*/ -} - -long -multi_cpu_exchange_add (volatile long *value, long rhs) -{ -#if defined (ACE_HAS_INTEL_ASSEMBLY) - unsigned long addr = reinterpret_cast (value); - asm( "lock ; xadd %0, (%1)" : "+r"(rhs) : "r"(addr) ); - return rhs; -#elif !defined (ACE_HAS_SOLARIS_ATOMIC_LIB) && (defined (sun) || \ - (defined (__SUNPRO_CC) && (defined (__i386) || defined (__x86_64)))) - return ace_atomic_swap_add_long ( - reinterpret_cast (value), rhs); -#elif defined (WIN32) && !defined (ACE_HAS_INTERLOCKED_EXCHANGEADD) -# if defined (_MSC_VER) - __asm - { - mov eax, rhs - mov edx, value - lock xadd [edx], eax - } - // Return value is already in EAX register. -# elif defined (__BORLANDC__) - _EAX = rhs; - _EDX = reinterpret_cast (value); - __emit__(0xF0, 0x0F, 0xC1, 0x02); // lock xadd [edx], eax - // Return value is already in EAX register. -# else /* _MSC_VER */ - ACE_UNUSED_ARG (value); - ACE_UNUSED_ARG (rhs); - ACE_NOTSUP_RETURN (-1); -# endif /* _MSC_VER */ -#else /* ACE_HAS_INTEL_ASSEMBLY*/ - ACE_UNUSED_ARG (value); - ACE_UNUSED_ARG (rhs); - ACE_NOTSUP_RETURN (-1); -#endif /* ACE_HAS_INTEL_ASSEMBLY*/ -} - -#if defined (_MSC_VER) -#pragma warning (pop) -#endif /* _MSC_VER */ - -} // end namespace - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -long (*ACE_Atomic_Op::increment_fn_) (volatile long *) = multi_cpu_increment; -long (*ACE_Atomic_Op::decrement_fn_) (volatile long *) = multi_cpu_decrement; -long (*ACE_Atomic_Op::exchange_fn_) (volatile long *, long) = multi_cpu_exchange; -long (*ACE_Atomic_Op::exchange_add_fn_) (volatile long *, long) = multi_cpu_exchange_add; - -void -ACE_Atomic_Op::init_functions (void) -{ - if (ACE_OS::num_processors () == 1) - { - increment_fn_ = single_cpu_increment; - decrement_fn_ = single_cpu_decrement; - exchange_fn_ = single_cpu_exchange; - exchange_add_fn_ = single_cpu_exchange_add; - } - else - { - increment_fn_ = multi_cpu_increment; - decrement_fn_ = multi_cpu_decrement; - exchange_fn_ = multi_cpu_exchange; - exchange_add_fn_ = multi_cpu_exchange_add; - } -} - -void -ACE_Atomic_Op::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -long (*ACE_Atomic_Op::increment_fn_) (volatile long *) = multi_cpu_increment; -long (*ACE_Atomic_Op::decrement_fn_) (volatile long *) = multi_cpu_decrement; -long (*ACE_Atomic_Op::exchange_fn_) (volatile long *, long) = multi_cpu_exchange; -long (*ACE_Atomic_Op::exchange_add_fn_) (volatile long *, long) = multi_cpu_exchange_add; - -void -ACE_Atomic_Op::init_functions (void) -{ - if (ACE_OS::num_processors () == 1) - { - increment_fn_ = single_cpu_increment; - decrement_fn_ = single_cpu_decrement; - exchange_fn_ = single_cpu_exchange; - exchange_add_fn_ = single_cpu_exchange_add; - } - else - { - increment_fn_ = multi_cpu_increment; - decrement_fn_ = multi_cpu_decrement; - exchange_fn_ = multi_cpu_exchange; - exchange_add_fn_ = multi_cpu_exchange_add; - } -} - -void -ACE_Atomic_Op::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_BUILTIN_ATOMIC_OP */ diff --git a/deps/acelite/ace/Atomic_Op.h b/deps/acelite/ace/Atomic_Op.h deleted file mode 100644 index b9b179c00..000000000 --- a/deps/acelite/ace/Atomic_Op.h +++ /dev/null @@ -1,380 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Atomic_Op.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_ATOMIC_OP_H -#define ACE_ATOMIC_OP_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Thread_Mutex.h" - -// Include the templates here. -#include "ace/Atomic_Op_T.h" - -// Determine whether builtin atomic op support is -// available on this platform. -#if defined (ACE_HAS_THREADS) -# if defined (WIN32) -# if defined (ACE_HAS_INTRINSIC_INTERLOCKED) -# define ACE_HAS_BUILTIN_ATOMIC_OP -# endif /* ACE_HAS_INTRINSIC_INTERLOCKED */ -# if defined (ACE_HAS_INTERLOCKED_EXCHANGEADD) -# define ACE_HAS_BUILTIN_ATOMIC_OP -# else /* ACE_HAS_INTERLOCKED_EXCHANGEADD */ - // Inline assembly emulation of InterlockedExchangeAdd - // is currently only implemented for MSVC (x86 only) and Borland. -# if (defined (_MSC_VER) && defined (_M_IX86)) || defined (__BORLANDC__) -# define ACE_HAS_BUILTIN_ATOMIC_OP -# endif /* _MSC_VER || __BORLANDC__ */ -# endif /* ACE_HAS_INTERLOCKED_EXCHANGEADD */ -# elif defined (ACE_HAS_INTEL_ASSEMBLY) -# define ACE_HAS_BUILTIN_ATOMIC_OP -# elif defined (ACE_HAS_VXATOMICLIB) -# define ACE_HAS_BUILTIN_ATOMIC_OP -# elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) && !defined (ACE_HAS_BUILTIN_ATOMIC_OP) -# define ACE_HAS_BUILTIN_ATOMIC_OP -# endif /* WIN32 */ -#endif /* ACE_HAS_THREADS */ - -// If we have the GCC Atomic builtin support, use it -#if defined (ACE_HAS_GCC_ATOMIC_BUILTINS) && (ACE_HAS_GCC_ATOMIC_BUILTINS == 1) -# undef ACE_HAS_BUILTIN_ATOMIC_OP -#endif - -// Include the templates here. -#include "ace/Atomic_Op_GCC_T.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_HAS_BUILTIN_ATOMIC_OP) - -/** - * @brief Specialization of ACE_Atomic_Op for platforms that - * support atomic integer operations. - * - * Specialization of ACE_Atomic_Op for platforms that support atomic - * integer operations. - */ -template<> -class ACE_Export ACE_Atomic_Op -{ -public: - /// Initialize @c value_ to 0. - ACE_Atomic_Op (void); - - /// Initialize @c value_ to c. - ACE_Atomic_Op (long c); - - /// Manage copying... - ACE_Atomic_Op (const ACE_Atomic_Op &c); - - /// Atomically pre-increment @c value_. - long operator++ (void); - - /// Atomically post-increment @c value_. - long operator++ (int); - - /// Atomically increment @c value_ by rhs. - long operator+= (long rhs); - - /// Atomically pre-decrement @c value_. - long operator-- (void); - - /// Atomically post-decrement @c value_. - long operator-- (int); - - /// Atomically decrement @c value_ by rhs. - long operator-= (long rhs); - - /// Atomically compare @c value_ with rhs. - bool operator== (long rhs) const; - - /// Atomically compare @c value_ with rhs. - bool operator!= (long rhs) const; - - /// Atomically check if @c value_ greater than or equal to rhs. - bool operator>= (long rhs) const; - - /// Atomically check if @c value_ greater than rhs. - bool operator> (long rhs) const; - - /// Atomically check if @c value_ less than or equal to rhs. - bool operator<= (long rhs) const; - - /// Atomically check if @c value_ less than rhs. - bool operator< (long rhs) const; - - /// Atomically assign rhs to @c value_. - ACE_Atomic_Op &operator= (long rhs); - - /// Atomically assign to @c value_. - ACE_Atomic_Op &operator= (const ACE_Atomic_Op &rhs); - - /// Exchange value with @a newval. - long exchange (long newval); - - /// Explicitly return @c value_. - long value (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Explicitly return @c value_ (by reference). - volatile long &value_i (void); - - // ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - - /// Used during ACE object manager initialization to optimize the fast - /// atomic op implementation according to the number of CPUs. - static void init_functions (void); - -private: - /// This function cannot be supported by this template specialization. - /// If you need access to an underlying lock, use the ACE_Atomic_Op_Ex - /// template instead. - ACE_Thread_Mutex &mutex (void); - -private: - /// Current object decorated by the atomic op. - volatile long value_; - - /// Pointers to selected atomic op implementations. - static long (*increment_fn_) (volatile long *); - static long (*decrement_fn_) (volatile long *); - static long (*exchange_fn_) (volatile long *, long); - static long (*exchange_add_fn_) (volatile long *, long); -}; - -/** - * @brief Specialization of ACE_Atomic_Op for platforms that - * support atomic integer operations. - * - * Specialization of ACE_Atomic_Op for platforms that support atomic - * integer operations. - */ -template<> -class ACE_Export ACE_Atomic_Op -{ -public: - /// Initialize @c value_ to 0. - ACE_Atomic_Op (void); - - /// Initialize @c value_ to c. - ACE_Atomic_Op (unsigned long c); - - /// Manage copying... - ACE_Atomic_Op (const ACE_Atomic_Op &c); - - /// Atomically pre-increment @c value_. - unsigned long operator++ (void); - - /// Atomically post-increment @c value_. - unsigned long operator++ (int); - - /// Atomically increment @c value_ by rhs. - unsigned long operator+= (unsigned long rhs); - - /// Atomically pre-decrement @c value_. - unsigned long operator-- (void); - - /// Atomically post-decrement @c value_. - unsigned long operator-- (int); - - /// Atomically decrement @c value_ by rhs. - unsigned long operator-= (unsigned long rhs); - - /// Atomically compare @c value_ with rhs. - bool operator== (unsigned long rhs) const; - - /// Atomically compare @c value_ with rhs. - bool operator!= (unsigned long rhs) const; - - /// Atomically check if @c value_ greater than or equal to rhs. - bool operator>= (unsigned long rhs) const; - - /// Atomically check if @c value_ greater than rhs. - bool operator> (unsigned long rhs) const; - - /// Atomically check if @c value_ less than or equal to rhs. - bool operator<= (unsigned long rhs) const; - - /// Atomically check if @c value_ less than rhs. - bool operator< (unsigned long rhs) const; - - /// Atomically assign rhs to @c value_. - ACE_Atomic_Op &operator= (unsigned long rhs); - - /// Atomically assign to @c value_. - ACE_Atomic_Op &operator= (const ACE_Atomic_Op &rhs); - - /// Exchange value with @a newval. - unsigned long exchange (unsigned long newval); - - /// Explicitly return @c value_. - unsigned long value (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Explicitly return @c value_ (by reference). - volatile unsigned long &value_i (void); - - // ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - - /// Used during ACE object manager initialization to optimize the fast - /// atomic op implementation according to the number of CPUs. - static void init_functions (void); - -private: - /// This function cannot be supported by this template specialization. - /// If you need access to an underlying lock, use the ACE_Atomic_Op_Ex - /// template instead. - ACE_Thread_Mutex &mutex (void); - -private: - /// Current object decorated by the atomic op. - volatile unsigned long value_; - - // Pointers to selected atomic op implementations. - static long (*increment_fn_) (volatile long *); - static long (*decrement_fn_) (volatile long *); - static long (*exchange_fn_) (volatile long *, long); - static long (*exchange_add_fn_) (volatile long *, long); -}; - -#endif /* !ACE_HAS_BUILTIN_ATOMIC_OP */ - -#if defined (ACE_HAS_GCC_ATOMIC_BUILTINS) && (ACE_HAS_GCC_ATOMIC_BUILTINS == 1) - -template<> -class ACE_Export ACE_Atomic_Op -: public ACE_Atomic_Op_GCC -{ -public: - ACE_Atomic_Op (void); - ACE_Atomic_Op (int c); - ACE_Atomic_Op (const ACE_Atomic_Op &c); - ACE_Atomic_Op &operator= (int rhs); -}; - -template<> -class ACE_Export ACE_Atomic_Op -: public ACE_Atomic_Op_GCC -{ -public: - ACE_Atomic_Op (void); - ACE_Atomic_Op (unsigned int c); - ACE_Atomic_Op (const ACE_Atomic_Op &c); - ACE_Atomic_Op &operator= (unsigned int rhs); -}; - -// If we have built in atomic op, use that, the assignment operator -// is faster for a long/unsinged long -template<> -class ACE_Export ACE_Atomic_Op -: public ACE_Atomic_Op_GCC -{ -public: - ACE_Atomic_Op (void); - ACE_Atomic_Op (long c); - ACE_Atomic_Op (const ACE_Atomic_Op &c); - ACE_Atomic_Op &operator= (long rhs); -}; - -template<> -class ACE_Export ACE_Atomic_Op -: public ACE_Atomic_Op_GCC -{ -public: - ACE_Atomic_Op (void); - ACE_Atomic_Op (unsigned long c); - ACE_Atomic_Op (const ACE_Atomic_Op &c); - ACE_Atomic_Op &operator= (unsigned long rhs); -}; - -// The long long intrinsics are not available on PPC -#if !defined (__powerpc__) -template<> -class ACE_Export ACE_Atomic_Op -: public ACE_Atomic_Op_GCC -{ -public: - ACE_Atomic_Op (void); - ACE_Atomic_Op (long long c); - ACE_Atomic_Op (const ACE_Atomic_Op &c); - ACE_Atomic_Op &operator= (long long rhs); -}; - -template<> -class ACE_Export ACE_Atomic_Op -: public ACE_Atomic_Op_GCC -{ -public: - ACE_Atomic_Op (void); - ACE_Atomic_Op (unsigned long long c); - ACE_Atomic_Op (const ACE_Atomic_Op &c); - ACE_Atomic_Op &operator= (unsigned long long rhs); -}; -#endif /* !__powerpc__ */ - -#if !defined (ACE_LACKS_GCC_ATOMIC_BUILTINS_2) -template<> -class ACE_Export ACE_Atomic_Op -: public ACE_Atomic_Op_GCC -{ -public: - ACE_Atomic_Op (void); - ACE_Atomic_Op (short c); - ACE_Atomic_Op (const ACE_Atomic_Op &c); - ACE_Atomic_Op &operator= (short rhs); -}; - -template<> -class ACE_Export ACE_Atomic_Op -: public ACE_Atomic_Op_GCC -{ -public: - ACE_Atomic_Op (void); - ACE_Atomic_Op (unsigned short c); - ACE_Atomic_Op (const ACE_Atomic_Op &c); - ACE_Atomic_Op &operator= (unsigned short rhs); -}; -#endif - -#if !defined (ACE_LACKS_GCC_ATOMIC_BUILTINS_1) -template<> -class ACE_Export ACE_Atomic_Op -: public ACE_Atomic_Op_GCC -{ -public: - ACE_Atomic_Op (void); - ACE_Atomic_Op (bool c); - ACE_Atomic_Op (const ACE_Atomic_Op &c); - ACE_Atomic_Op &operator= (bool rhs); -}; -#endif - -#endif /* ACE_HAS_BUILTIN_ATOMIC_OP */ - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Atomic_Op.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /*ACE_ATOMIC_OP_H*/ diff --git a/deps/acelite/ace/Atomic_Op.inl b/deps/acelite/ace/Atomic_Op.inl deleted file mode 100644 index 2f9ec57ba..000000000 --- a/deps/acelite/ace/Atomic_Op.inl +++ /dev/null @@ -1,666 +0,0 @@ -// -*- C++ -*- -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) -# include "ace/os_include/os_intrin.h" -# pragma intrinsic (_InterlockedExchange, _InterlockedExchangeAdd, _InterlockedIncrement, _InterlockedDecrement) -#endif /* ACE_HAS_INTRINSIC_INTERLOCKED */ - -#if defined (ACE_HAS_VXATOMICLIB) -# include -#endif - -#if defined (ACE_HAS_SOLARIS_ATOMIC_LIB) -# include -#endif - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_HAS_BUILTIN_ATOMIC_OP) - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (void) - : value_ (0) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (long c) - : value_ (c) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op ( - const ACE_Atomic_Op &rhs) - : value_ (rhs.value_) -{ -} - -ACE_INLINE long -ACE_Atomic_Op::operator++ (void) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - return ::_InterlockedIncrement (const_cast (&this->value_)); -#elif defined (WIN32) - return ::InterlockedIncrement (const_cast (&this->value_)); -#elif defined (ACE_HAS_VXATOMICLIB) - return ::vxAtomicInc (reinterpret_cast (const_cast (&this->value_))) + 1; -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - return ::atomic_inc_ulong_nv (reinterpret_cast(&this->value_)); -#else /* WIN32 */ - return (*increment_fn_) (&this->value_); -#endif /* WIN32 */ -} - -ACE_INLINE long -ACE_Atomic_Op::operator++ (int) -{ - return ++*this - 1; -} - -ACE_INLINE long -ACE_Atomic_Op::operator-- (void) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - return ::_InterlockedDecrement (const_cast (&this->value_)); -#elif defined (WIN32) - return ::InterlockedDecrement (const_cast (&this->value_)); -#elif defined (ACE_HAS_VXATOMICLIB) - return ::vxAtomicDec (reinterpret_cast (const_cast (&this->value_))) - 1; -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - return ::atomic_dec_ulong_nv (reinterpret_cast(&this->value_)); -#else /* WIN32 */ - return (*decrement_fn_) (&this->value_); -#endif /* WIN32 */ -} - -ACE_INLINE long -ACE_Atomic_Op::operator-- (int) -{ - return --*this + 1; -} - -ACE_INLINE long -ACE_Atomic_Op::operator+= (long rhs) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - return ::_InterlockedExchangeAdd (const_cast (&this->value_), - rhs) + rhs; -#elif defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD) - return ::InterlockedExchangeAdd (const_cast (&this->value_), - rhs) + rhs; -#elif defined (ACE_HAS_VXATOMICLIB) - return ::vxAtomicAdd (reinterpret_cast (const_cast (&this->value_)), rhs) + rhs; -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - return ::atomic_add_long_nv (reinterpret_cast(&this->value_), rhs); -#else /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */ - return (*exchange_add_fn_) (&this->value_, rhs) + rhs; -#endif /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */ -} - -ACE_INLINE long -ACE_Atomic_Op::operator-= (long rhs) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - return ::_InterlockedExchangeAdd (const_cast (&this->value_), - -rhs) - rhs; -#elif defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD) - return ::InterlockedExchangeAdd (const_cast (&this->value_), - -rhs) - rhs; -#elif defined (ACE_HAS_VXATOMICLIB) - return ::vxAtomicSub (reinterpret_cast (const_cast (&this->value_)), rhs) - rhs; -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - return ::atomic_add_long_nv (reinterpret_cast(&this->value_), -rhs); -#else /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */ - return (*exchange_add_fn_) (&this->value_, -rhs) - rhs; -#endif /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */ -} - -ACE_INLINE bool -ACE_Atomic_Op::operator== (long rhs) const -{ - return (this->value_ == rhs); -} - -ACE_INLINE bool -ACE_Atomic_Op::operator!= (long rhs) const -{ - return (this->value_ != rhs); -} - -ACE_INLINE bool -ACE_Atomic_Op::operator>= (long rhs) const -{ - return (this->value_ >= rhs); -} - -ACE_INLINE bool -ACE_Atomic_Op::operator> (long rhs) const -{ - return (this->value_ > rhs); -} - -ACE_INLINE bool -ACE_Atomic_Op::operator<= (long rhs) const -{ - return (this->value_ <= rhs); -} - -ACE_INLINE bool -ACE_Atomic_Op::operator< (long rhs) const -{ - return (this->value_ < rhs); -} - -ACE_INLINE ACE_Atomic_Op & -ACE_Atomic_Op::operator= (long rhs) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - ::_InterlockedExchange (const_cast (&this->value_), rhs); -#elif defined (WIN32) - ::InterlockedExchange (const_cast (&this->value_), rhs); -#elif defined (ACE_HAS_VXATOMICLIB) - ::vxAtomicSet (reinterpret_cast (const_cast (&this->value_)), rhs); -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - ::atomic_swap_ulong (reinterpret_cast(&this->value_), rhs); -#else /* WIN32 */ - (*exchange_fn_) (&this->value_, rhs); -#endif /* WIN32 */ - return *this; -} - -ACE_INLINE ACE_Atomic_Op & -ACE_Atomic_Op::operator= ( - const ACE_Atomic_Op &rhs) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - ::_InterlockedExchange (const_cast (&this->value_), rhs.value_); -#elif defined (WIN32) - ::InterlockedExchange (const_cast (&this->value_), rhs.value_); -#elif defined (ACE_HAS_VXATOMICLIB) - ::vxAtomicSet (reinterpret_cast (const_cast (&this->value_)), rhs.value_); -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - ::atomic_swap_ulong (reinterpret_cast(&this->value_), rhs.value_); -#else /* WIN32 */ - (*exchange_fn_) (&this->value_, rhs.value_); -#endif /* WIN32 */ - return *this; -} - -ACE_INLINE long -ACE_Atomic_Op::exchange (long newval) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - return ::_InterlockedExchange (const_cast (&this->value_), newval); -#elif defined (WIN32) - return ::InterlockedExchange (const_cast (&this->value_), newval); -#elif defined (ACE_HAS_VXATOMICLIB) - return ::vxAtomicSet (reinterpret_cast (const_cast (&this->value_)), newval); -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - return ::atomic_swap_ulong (reinterpret_cast(&this->value_), newval); -#else /* WIN32 */ - return (*exchange_fn_) (&this->value_, newval); -#endif /* WIN32 */ -} - -ACE_INLINE long -ACE_Atomic_Op::value (void) const -{ - return this->value_; -} - -ACE_INLINE volatile long & -ACE_Atomic_Op::value_i (void) -{ - return this->value_; -} - - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (void) - : value_ (0) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (unsigned long c) - : value_ (c) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op ( - const ACE_Atomic_Op &rhs) - : value_ (rhs.value_) -{ -} - -ACE_INLINE unsigned long -ACE_Atomic_Op::operator++ (void) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - return static_cast (::_InterlockedIncrement (const_cast (reinterpret_cast(&this->value_)))); -#elif defined (WIN32) - return static_cast (::InterlockedIncrement (const_cast (reinterpret_cast(&this->value_)))); -#elif defined (ACE_HAS_VXATOMICLIB) - return static_cast (::vxAtomicInc (reinterpret_cast (const_cast (reinterpret_cast(&this->value_))))) + 1; -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - return ::atomic_inc_ulong_nv (&this->value_); -#else /* WIN32 */ - return static_cast ((*increment_fn_) (reinterpret_cast (&this->value_))); -#endif /* WIN32 */ -} - -ACE_INLINE unsigned long -ACE_Atomic_Op::operator++ (int) -{ - return ++*this - 1; -} - -ACE_INLINE unsigned long -ACE_Atomic_Op::operator-- (void) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - return static_cast (::_InterlockedDecrement (const_cast (reinterpret_cast(&this->value_)))); -#elif defined (WIN32) - return static_cast (::InterlockedDecrement (const_cast (reinterpret_cast(&this->value_)))); -#elif defined (ACE_HAS_VXATOMICLIB) - return static_cast (::vxAtomicDec (reinterpret_cast (const_cast (reinterpret_cast(&this->value_))))) - 1; -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - return ::atomic_dec_ulong_nv (&this->value_); -#else /* WIN32 */ - return static_cast ((*decrement_fn_) (reinterpret_cast (&this->value_))); -#endif /* WIN32 */ -} - -ACE_INLINE unsigned long -ACE_Atomic_Op::operator-- (int) -{ - return --*this + 1; -} - -ACE_INLINE unsigned long -ACE_Atomic_Op::operator+= (unsigned long rhs) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - return static_cast (::_InterlockedExchangeAdd (const_cast (reinterpret_cast (&this->value_)), - rhs)) + rhs; -#elif defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD) - return static_cast (::InterlockedExchangeAdd (const_cast (reinterpret_cast (&this->value_)), - rhs)) + rhs; -#elif defined (ACE_HAS_VXATOMICLIB) - return static_cast (::vxAtomicAdd (reinterpret_cast (const_cast (reinterpret_cast(&this->value_))), rhs)) + rhs; -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - return ::atomic_add_long_nv (&this->value_, rhs); -#else /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */ - return static_cast ((*exchange_add_fn_) (reinterpret_cast (&this->value_), rhs)) + rhs; -#endif /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */ -} - -ACE_INLINE unsigned long -ACE_Atomic_Op::operator-= (unsigned long rhs) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - return static_cast (::_InterlockedExchangeAdd (const_cast (reinterpret_cast(&this->value_)), - -static_cast(rhs))) - rhs; -#elif defined (WIN32) && defined (ACE_HAS_INTERLOCKED_EXCHANGEADD) - return static_cast (::InterlockedExchangeAdd (const_cast (reinterpret_cast(&this->value_)), - -static_cast(rhs))) - rhs; -#elif defined (ACE_HAS_VXATOMICLIB) - return static_cast (::vxAtomicSub (reinterpret_cast (const_cast (reinterpret_cast(&this->value_))), rhs)) - rhs; -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - return ::atomic_add_long_nv (&this->value_, -rhs); -#else /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */ - long l_rhs = static_cast (rhs); - return static_cast ((*exchange_add_fn_) (reinterpret_cast (&this->value_), -l_rhs)) - rhs; -#endif /* WIN32 && ACE_HAS_INTERLOCKED_EXCHANGEADD */ -} - -ACE_INLINE bool -ACE_Atomic_Op::operator== (unsigned long rhs) const -{ - return (this->value_ == rhs); -} - -ACE_INLINE bool -ACE_Atomic_Op::operator!= (unsigned long rhs) const -{ - return (this->value_ != rhs); -} - -ACE_INLINE bool -ACE_Atomic_Op::operator>= (unsigned long rhs) const -{ - return (this->value_ >= rhs); -} - -ACE_INLINE bool -ACE_Atomic_Op::operator> (unsigned long rhs) const -{ - return (this->value_ > rhs); -} - -ACE_INLINE bool -ACE_Atomic_Op::operator<= (unsigned long rhs) const -{ - return (this->value_ <= rhs); -} - -ACE_INLINE bool -ACE_Atomic_Op::operator< (unsigned long rhs) const -{ - return (this->value_ < rhs); -} - -ACE_INLINE ACE_Atomic_Op & -ACE_Atomic_Op::operator= (unsigned long rhs) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - ::_InterlockedExchange (const_cast (reinterpret_cast (&this->value_)), rhs); -#elif defined (WIN32) - ::InterlockedExchange (const_cast (reinterpret_cast (&this->value_)), rhs); -#elif defined (ACE_HAS_VXATOMICLIB) - ::vxAtomicSet (reinterpret_cast (const_cast (reinterpret_cast (&this->value_))), rhs); -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - ::atomic_swap_ulong (&this->value_, rhs); -#else /* WIN32 */ - (*exchange_fn_) (reinterpret_cast (&this->value_), rhs); -#endif /* WIN32 */ - return *this; -} - -ACE_INLINE ACE_Atomic_Op & -ACE_Atomic_Op::operator= ( - const ACE_Atomic_Op &rhs) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - ::_InterlockedExchange (const_cast (reinterpret_cast (&this->value_)), rhs.value_); -#elif defined (WIN32) - ::InterlockedExchange (const_cast (reinterpret_cast (&this->value_)), rhs.value_); -#elif defined (ACE_HAS_VXATOMICLIB) - ::vxAtomicSet (reinterpret_cast (const_cast (reinterpret_cast (&this->value_))), rhs.value_); -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - ::atomic_swap_ulong (&this->value_, rhs.value_); -#else /* WIN32 */ - (*exchange_fn_) (reinterpret_cast (&this->value_), rhs.value_); -#endif /* WIN32 */ - return *this; -} - -ACE_INLINE unsigned long -ACE_Atomic_Op::exchange (unsigned long newval) -{ -#if defined (ACE_HAS_INTRINSIC_INTERLOCKED) - return ::_InterlockedExchange (const_cast (reinterpret_cast (&this->value_)), newval); -#elif defined (WIN32) - return ::InterlockedExchange (const_cast (reinterpret_cast (&this->value_)), newval); -#elif defined (ACE_HAS_VXATOMICLIB) - return ::vxAtomicSet (reinterpret_cast (const_cast (reinterpret_cast (&this->value_))), newval); -#elif defined (ACE_HAS_SOLARIS_ATOMIC_LIB) - return ::atomic_swap_ulong (&this->value_, newval); -#else /* WIN32 */ - return (*exchange_fn_) (reinterpret_cast (&this->value_), newval); -#endif /* WIN32 */ -} - -ACE_INLINE unsigned long -ACE_Atomic_Op::value (void) const -{ - return this->value_; -} - -ACE_INLINE volatile unsigned long & -ACE_Atomic_Op::value_i (void) -{ - return this->value_; -} - -#endif /* ACE_HAS_BUILTIN_ATOMIC_OP */ - -#if defined (ACE_HAS_GCC_ATOMIC_BUILTINS) && (ACE_HAS_GCC_ATOMIC_BUILTINS == 1) - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (void) : - ACE_Atomic_Op_GCC () -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (int c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (const ACE_Atomic_Op &c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op& -ACE_Atomic_Op::operator= (int rhs) -{ - ACE_Atomic_Op_GCC::operator= (rhs); - return *this; -} - - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (void) : - ACE_Atomic_Op_GCC() -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (const ACE_Atomic_Op &c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (unsigned int c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op& -ACE_Atomic_Op::operator= (unsigned int rhs) -{ - ACE_Atomic_Op_GCC::operator= (rhs); - return *this; -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (void) : - ACE_Atomic_Op_GCC() -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (long c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (const ACE_Atomic_Op &c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op& -ACE_Atomic_Op::operator= (long rhs) -{ - ACE_Atomic_Op_GCC::operator= (rhs); - return *this; -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (void) : - ACE_Atomic_Op_GCC () -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (unsigned long c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (const ACE_Atomic_Op &c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op& -ACE_Atomic_Op::operator= (unsigned long rhs) -{ - ACE_Atomic_Op_GCC::operator= (rhs); - return *this; -} - -// The long long intrinsics are not available on PPC -#if !defined (__powerpc__) -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (void) : - ACE_Atomic_Op_GCC() -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (long long c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (const ACE_Atomic_Op &c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op& -ACE_Atomic_Op::operator= (long long rhs) -{ - ACE_Atomic_Op_GCC::operator= (rhs); - return *this; -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (void) : - ACE_Atomic_Op_GCC () -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (unsigned long long c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (const ACE_Atomic_Op &c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op& -ACE_Atomic_Op::operator= (unsigned long long rhs) -{ - ACE_Atomic_Op_GCC::operator= (rhs); - return *this; -} -#endif /* !__powerpc__ */ - -#if !defined (ACE_LACKS_GCC_ATOMIC_BUILTINS_2) -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (void) : - ACE_Atomic_Op_GCC() -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (short c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (const ACE_Atomic_Op &c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op& -ACE_Atomic_Op::operator= (short rhs) -{ - ACE_Atomic_Op_GCC::operator= (rhs); - return *this; -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (void) : - ACE_Atomic_Op_GCC () -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (unsigned short c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (const ACE_Atomic_Op &c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op& -ACE_Atomic_Op::operator= (unsigned short rhs) -{ - ACE_Atomic_Op_GCC::operator= (rhs); - return *this; -} -#endif - -#if !defined (ACE_LACKS_GCC_ATOMIC_BUILTINS_1) -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (void) : - ACE_Atomic_Op_GCC () -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (bool c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op (const ACE_Atomic_Op &c) : - ACE_Atomic_Op_GCC(c) -{ -} - -ACE_INLINE -ACE_Atomic_Op& -ACE_Atomic_Op::operator= (bool rhs) -{ - ACE_Atomic_Op_GCC::operator= (rhs); - return *this; -} -#endif - -#endif /* ACE_HAS_GCC_ATOMIC_BUILTINS==1 */ - -ACE_END_VERSIONED_NAMESPACE_DECL - diff --git a/deps/acelite/ace/Atomic_Op_GCC_T.cpp b/deps/acelite/ace/Atomic_Op_GCC_T.cpp deleted file mode 100644 index 3e7e7cada..000000000 --- a/deps/acelite/ace/Atomic_Op_GCC_T.cpp +++ /dev/null @@ -1,23 +0,0 @@ -#include "ace/OS_NS_unistd.h" - -#if defined (ACE_HAS_GCC_ATOMIC_BUILTINS) && (ACE_HAS_GCC_ATOMIC_BUILTINS == 1) - -#if !defined (__ACE_INLINE__) -#include "ace/Atomic_Op_GCC_T.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -void -ACE_Atomic_Op_GCC::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_GCC_ATOMIC_BUILTINS */ diff --git a/deps/acelite/ace/Atomic_Op_GCC_T.h b/deps/acelite/ace/Atomic_Op_GCC_T.h deleted file mode 100644 index 38485af3b..000000000 --- a/deps/acelite/ace/Atomic_Op_GCC_T.h +++ /dev/null @@ -1,135 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Atomic_Op_GCC_T.h - * - * @author Johnny Willemsen -class ACE_Export ACE_Atomic_Op_GCC -{ -public: - /// Atomically pre-increment @c value_. - T operator++ (void); - - /// Atomically post-increment @c value_. - T operator++ (int); - - /// Atomically increment @c value_ by rhs. - T operator+= (T rhs); - - /// Atomically pre-decrement @c value_. - T operator-- (void); - - /// Atomically post-decrement @c value_. - T operator-- (int); - - /// Atomically decrement @c value_ by rhs. - T operator-= (T rhs); - - /// Atomically compare @c value_ with rhs. - bool operator== (T rhs) const; - - /// Atomically compare @c value_ with rhs. - bool operator!= (T rhs) const; - - /// Atomically check if @c value_ greater than or equal to rhs. - bool operator>= (T rhs) const; - - /// Atomically check if @c value_ greater than rhs. - bool operator> (T rhs) const; - - /// Atomically check if @c value_ less than or equal to rhs. - bool operator<= (T rhs) const; - - /// Atomically check if @c value_ less than rhs. - bool operator< (T rhs) const; - - /// Exchange value with @a newval. - T exchange (T newval); - - /// Explicitly return @c value_. - T value (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Explicitly return @c value_ (by reference). - volatile T &value_i (void); - - // ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -protected: - /// Atomically assign rhs to @c value_. - ACE_Atomic_Op_GCC &operator= (T rhs); - - /// Atomically assign to @c value_. - ACE_Atomic_Op_GCC &operator= (const ACE_Atomic_Op_GCC &rhs); - - /// Initialize @c value_ to 0. - ACE_Atomic_Op_GCC (void); - - /// Initialize @c value_ to c. - ACE_Atomic_Op_GCC (T c); - - /// Manage copying... - ACE_Atomic_Op_GCC (const ACE_Atomic_Op_GCC &c); - -private: - // This function cannot be supported by this template specialization. - // If you need access to an underlying lock, use the ACE_Atomic_Op_Ex - // template instead. - ACE_Thread_Mutex &mutex (void); - -private: - /// Current object decorated by the atomic op. - volatile T value_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Atomic_Op_GCC_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Atomic_Op_GCC_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Atomic_Op_GCC_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - - -#endif /* ACE_HAS_GCC_ATOMIC_BUILTINS */ - -#include /**/ "ace/post.h" -#endif /*ACE_ATOMIC_OP_GCC_T_H*/ diff --git a/deps/acelite/ace/Atomic_Op_GCC_T.inl b/deps/acelite/ace/Atomic_Op_GCC_T.inl deleted file mode 100644 index 90f7c4839..000000000 --- a/deps/acelite/ace/Atomic_Op_GCC_T.inl +++ /dev/null @@ -1,152 +0,0 @@ -// -*- C++ -*- -#if defined (ACE_HAS_GCC_ATOMIC_BUILTINS) && (ACE_HAS_GCC_ATOMIC_BUILTINS == 1) - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_INLINE -ACE_Atomic_Op_GCC::ACE_Atomic_Op_GCC (void) - : value_ (0) -{ -} - -template -ACE_INLINE -ACE_Atomic_Op_GCC::ACE_Atomic_Op_GCC (T c) - : value_ (c) -{ -} - -template -ACE_INLINE -ACE_Atomic_Op_GCC::ACE_Atomic_Op_GCC ( - const ACE_Atomic_Op_GCC &rhs) - : value_ (rhs.value_) -{ -} - -template -ACE_INLINE T -ACE_Atomic_Op_GCC::operator++ (void) -{ - return __sync_add_and_fetch (&this->value_, 1); -} - -template -ACE_INLINE T -ACE_Atomic_Op_GCC::operator++ (int) -{ - return __sync_fetch_and_add (&this->value_, 1); -} - -template -ACE_INLINE T -ACE_Atomic_Op_GCC::operator-- (void) -{ - return __sync_sub_and_fetch (&this->value_, 1); -} - -template -ACE_INLINE T -ACE_Atomic_Op_GCC::operator-- (int) -{ - return __sync_fetch_and_sub (&this->value_, 1); -} - -template -ACE_INLINE T -ACE_Atomic_Op_GCC::operator+= (T rhs) -{ - return __sync_add_and_fetch (&this->value_, rhs); -} - -template -ACE_INLINE T -ACE_Atomic_Op_GCC::operator-= (T rhs) -{ - return __sync_sub_and_fetch (&this->value_, rhs); -} - -template -ACE_INLINE bool -ACE_Atomic_Op_GCC::operator== (T rhs) const -{ - return (this->value_ == rhs); -} - -template -ACE_INLINE bool -ACE_Atomic_Op_GCC::operator!= (T rhs) const -{ - return (this->value_ != rhs); -} - -template -ACE_INLINE bool -ACE_Atomic_Op_GCC::operator>= (T rhs) const -{ - return (this->value_ >= rhs); -} - -template -ACE_INLINE bool -ACE_Atomic_Op_GCC::operator> (T rhs) const -{ - return (this->value_ > rhs); -} - -template -ACE_INLINE bool -ACE_Atomic_Op_GCC::operator<= (T rhs) const -{ - return (this->value_ <= rhs); -} - -template -ACE_INLINE bool -ACE_Atomic_Op_GCC::operator< (T rhs) const -{ - return (this->value_ < rhs); -} - -template -ACE_INLINE ACE_Atomic_Op_GCC & -ACE_Atomic_Op_GCC::operator= (T rhs) -{ - (void) __sync_lock_test_and_set (&this->value_, rhs); - return *this; -} - -template -ACE_INLINE ACE_Atomic_Op_GCC & -ACE_Atomic_Op_GCC::operator= ( - const ACE_Atomic_Op_GCC &rhs) -{ - (void) __sync_lock_test_and_set (&this->value_, rhs.value_); - return *this; -} - -template -ACE_INLINE T -ACE_Atomic_Op_GCC::exchange (T newval) -{ - return __sync_val_compare_and_swap (&this->value_, this->value_, newval); -} - -template -ACE_INLINE T -ACE_Atomic_Op_GCC::value (void) const -{ - return this->value_; -} - -template -ACE_INLINE volatile T & -ACE_Atomic_Op_GCC::value_i (void) -{ - return this->value_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_GCC_ATOMIC_BUILTINS */ diff --git a/deps/acelite/ace/Atomic_Op_Sparc.c b/deps/acelite/ace/Atomic_Op_Sparc.c deleted file mode 100644 index 9e59864ae..000000000 --- a/deps/acelite/ace/Atomic_Op_Sparc.c +++ /dev/null @@ -1,187 +0,0 @@ -/* - * - * This is a C file for a reason. The Sun C++ compiler does not accept - * inline assembler. - * - * Portions of this code are based on atomic operations found in the - * linux kernel source code. - */ - -#if defined (ACE_INCLUDE_ATOMIC_OP_SPARC) - -#if defined(__i386) && defined(__SUNPRO_C) -static void -__sunpro_asm_code() { - __asm("\n\ - .globl ace_atomic_add_long \n\ - .type ace_atomic_add_long,@function \n\ - .align 4 \n\ -ace_atomic_add_long: \n\ - movl 0x00000004(%esp), %edx \n\ - movl 0x00000008(%esp), %eax \n\ - lock; xadd %eax, (%edx) \n\ - addl 0x00000008(%esp), %eax \n\ - ret \n\ - "); - - __asm("\n\ - .globl ace_atomic_swap_long \n\ - .type ace_atomic_swap_long,@function \n\ - .align 4 \n\ -ace_atomic_swap_long: \n\ - movl 0x00000004(%esp), %edx \n\ - movl 0x00000008(%esp), %eax \n\ - xchg %eax, (%edx) \n\ - ret \n\ - "); - - __asm("\n\ - .globl ace_atomic_swap_add_long \n\ - .type ace_atomic_swap_add_long,@function \n\ - .align 4 \n\ -ace_atomic_swap_add_long: \n\ - movl 0x00000004(%esp), %edx \n\ - movl 0x00000008(%esp), %eax \n\ - lock; xadd %eax, (%edx) \n\ - ret \n\ - "); -} - -#elif defined(__x86_64) && defined(__SUNPRO_C) - -static void -__sunpro_asm_code() { - __asm("\n\ - .globl ace_atomic_add_long \n\ - .type ace_atomic_add_long,@function \n\ - .align 16 \n\ -ace_atomic_add_long: \n\ - movq %rsi, %rax \n\ - lock; xaddq %rax, (%rdi) \n\ - addq %rsi, %rax \n\ - ret \n\ - "); - - __asm("\n\ - .globl ace_atomic_swap_long \n\ - .type ace_atomic_swap_long,@function \n\ - .align 16 \n\ -ace_atomic_swap_long: \n\ - xchgq %rsi, (%rdi) \n\ - movq %rsi, %rax \n\ - ret \n\ - "); - - __asm("\n\ - .globl ace_atomic_swap_add_long \n\ - .type ace_atomic_swap_add_long,@function \n\ - .align 16 \n\ -ace_atomic_swap_add_long: \n\ - lock; xaddq %rsi, (%rdi) \n\ - movq %rsi, %rax \n\ - ret \n\ - "); -} - -#elif defined (__sparcv9) - -unsigned long -ace_atomic_add_long (volatile unsigned long *dest, long rhs) -{ - __asm ("restore\n" - "ldx [%o0], %o2\n" - ".again_add:\n" - "add %o2, %o1, %o3\n" - "casx [%o0], %o2, %o3\n" - "cmp %o2, %o3\n" - "bne,pn %xcc, .again_add\n" - "mov %o3, %o2\n" - "retl\n" - "add %o2, %o1, %o0\n"); -} - -unsigned long -ace_atomic_swap_long (volatile unsigned long *dest, unsigned long rhs) -{ - __asm ("restore\n" - "ldx [%o0], %o2\n" - ".again_swap:\n" - "mov %o1, %o3\n" - "casx [%o0], %o2, %o3\n" - "cmp %o2, %o3\n" - "bne,pn %xcc, .again_swap\n" - "mov %o3, %o2\n" - "retl\n" - "mov %o3, %o0\n"); -} - -unsigned long -ace_atomic_swap_add_long (volatile unsigned long *dest, long rhs) -{ - __asm ("restore\n" - "ldx [%o0], %o2\n" - ".again_swap_add:\n" - "mov %o2, %o4\n" - "add %o2, %o1, %o3\n" - "casx [%o0], %o2, %o3\n" - "cmp %o2, %o3\n" - "bne,pn %xcc, .again_swap_add\n" - "mov %o3, %o2\n" - "retl\n" - "mov %o4, %o0\n"); -} - -#else - -unsigned long -ace_atomic_add_long (volatile unsigned long *dest, long rhs) -{ - __asm ("restore\n" - "ld [%o0], %o2\n" - ".again_add:\n" - "add %o2, %o1, %o3\n" - "cas [%o0], %o2, %o3\n" - "cmp %o2, %o3\n" - "bne,pn %icc, .again_add\n" - "mov %o3, %o2\n" - "retl\n" - "add %o2, %o1, %o0\n"); -} - -unsigned long -ace_atomic_swap_long (volatile unsigned long *dest, unsigned long rhs) -{ - __asm ("restore\n" - "ld [%o0], %o2\n" - ".again_swap:\n" - "mov %o1, %o3\n" - "cas [%o0], %o2, %o3\n" - "cmp %o2, %o3\n" - "bne,pn %icc, .again_swap\n" - "mov %o3, %o2\n" - "retl\n" - "mov %o3, %o0\n"); -} - -unsigned long -ace_atomic_swap_add_long (volatile unsigned long *dest, long rhs) -{ - __asm ("restore\n" - "ld [%o0], %o2\n" - ".again_swap_add:\n" - "mov %o2, %o4\n" - "add %o2, %o1, %o3\n" - "cas [%o0], %o2, %o3\n" - "cmp %o2, %o3\n" - "bne,pn %icc, .again_swap_add\n" - "mov %o3, %o2\n" - "retl\n" - "mov %o4, %o0\n"); -} - -# endif /* __sparcv9 */ - -#elif !defined (__GNUC__) && !defined (__INTEL_COMPILER) -/* Make compilers stop complaining about an empty translation unit */ -static int shut_up_compiler = 0; -#endif /* ACE_INCLUDE_ATOMIC_OP_SPARC */ diff --git a/deps/acelite/ace/Atomic_Op_Sparc.h b/deps/acelite/ace/Atomic_Op_Sparc.h deleted file mode 100644 index 3c4d883c2..000000000 --- a/deps/acelite/ace/Atomic_Op_Sparc.h +++ /dev/null @@ -1,12 +0,0 @@ -/* -*- C++ -*- */ -#ifndef ACE_ATOMIC_OP_SPARC_H -#define ACE_ATOMIC_OP_SPARC_H - -extern "C" -{ - unsigned long ace_atomic_add_long (volatile unsigned long *dest, long rhs); - unsigned long ace_atomic_swap_long (volatile unsigned long *dest, unsigned long rhs); - unsigned long ace_atomic_swap_add_long (volatile unsigned long *dest, long rhs); -} - -#endif /* ACE_ATOMIC_OP_SPARC_H */ diff --git a/deps/acelite/ace/Atomic_Op_T.cpp b/deps/acelite/ace/Atomic_Op_T.cpp deleted file mode 100644 index d925d6e46..000000000 --- a/deps/acelite/ace/Atomic_Op_T.cpp +++ /dev/null @@ -1,84 +0,0 @@ -#ifndef ACE_ATOMIC_OP_T_CPP -#define ACE_ATOMIC_OP_T_CPP - -#include "ace/Atomic_Op_T.h" - -#ifdef ACE_HAS_DUMP -# include "ace/Log_Category.h" -#endif /* ACE_HAS_DUMP */ - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (__ACE_INLINE__) -#include "ace/Atomic_Op_T.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Atomic_Op_Ex) -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Atomic_Op) - -// ************************************************* -template ACE_LOCK & -ACE_Atomic_Op_Ex::mutex (void) -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::mutex"); - return this->mutex_; -} - -template -void -ACE_Atomic_Op_Ex::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - // ACE_TRACE ("ACE_Atomic_Op_Ex::dump"); - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->mutex_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Atomic_Op_Ex::ACE_Atomic_Op_Ex (ACE_LOCK & mtx) - : mutex_ (mtx) - , value_ (0) -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::ACE_Atomic_Op_Ex"); -} - -template -ACE_Atomic_Op_Ex::ACE_Atomic_Op_Ex ( - ACE_LOCK & mtx, - typename ACE_Atomic_Op_Ex::arg_type c) - : mutex_ (mtx) - , value_ (c) -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::ACE_Atomic_Op_Ex"); -} - -// **************************************************************** - -template -ACE_Atomic_Op::ACE_Atomic_Op (void) - : impl_ (this->own_mutex_) -{ - // ACE_TRACE ("ACE_Atomic_Op::ACE_Atomic_Op"); -} - -template -ACE_Atomic_Op::ACE_Atomic_Op ( - typename ACE_Atomic_Op::arg_type c) - : impl_ (own_mutex_, c) -{ - // ACE_TRACE ("ACE_Atomic_Op::ACE_Atomic_Op"); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_ATOMIC_OP_T_CPP */ diff --git a/deps/acelite/ace/Atomic_Op_T.h b/deps/acelite/ace/Atomic_Op_T.h deleted file mode 100644 index c3d936c1f..000000000 --- a/deps/acelite/ace/Atomic_Op_T.h +++ /dev/null @@ -1,356 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Atomic_Op_T.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_ATOMIC_OP_T_H -#define ACE_ATOMIC_OP_T_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -struct ACE_Type_Traits -{ - typedef TYPE const & parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef bool parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef char parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef signed char parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef unsigned char parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef short parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef unsigned short parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef int parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef unsigned int parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef long parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef unsigned long parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef long long parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef unsigned long long parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef float parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef double parameter_type; -}; - -template<> -struct ACE_Type_Traits -{ - typedef long double parameter_type; -}; - -template -struct ACE_Type_Traits -{ - typedef TYPE* parameter_type; -}; - -/** - * @class ACE_Atomic_Op_Ex - * - * @brief Transparently parameterizes synchronization into basic - * arithmetic operations. - * - * This class is described in an article in the July/August 1994 - * issue of the C++ Report magazine. It implements a - * templatized version of the Decorator pattern from the GoF book. - * - * ACE_Atomic_Op_Ex objects must be constructed with a reference - * to an existing lock. A single lock can be shared between - * multiple ACE_Atomic_Op_Ex objects. If you do not require this - * ability consider using the ACE_Atomic_Op class instead, which - * may be able to take advantage of platform-specific - * optimisations to provide atomic operations without requiring a - * lock. - */ -template -class ACE_Atomic_Op_Ex -{ -public: - typedef typename ACE_Type_Traits::parameter_type arg_type; - - /// Initialize @c value_ to 0. - ACE_Atomic_Op_Ex (ACE_LOCK & mtx); - - /// Initialize @c value_ to c. - ACE_Atomic_Op_Ex (ACE_LOCK & mtx, arg_type c); - - // = Accessors. - - /// Atomically pre-increment @c value_. - TYPE operator++ (void); - - /// Atomically post-increment @c value_. - TYPE operator++ (int); - - /// Atomically increment @c value_ by rhs. - TYPE operator+= (arg_type rhs); - - /// Atomically pre-decrement @c value_. - TYPE operator-- (void); - - /// Atomically post-decrement @c value_. - TYPE operator-- (int); - - /// Atomically decrement @c value_ by rhs. - TYPE operator-= (arg_type rhs); - - /// Atomically compare @c value_ with rhs. - bool operator== (arg_type rhs) const; - - /// Atomically compare @c value_ with rhs. - bool operator!= (arg_type rhs) const; - - /// Atomically check if @c value_ greater than or equal to rhs. - bool operator>= (arg_type rhs) const; - - /// Atomically check if @c value_ greater than rhs. - bool operator> (arg_type rhs) const; - - /// Atomically check if @c value_ less than or equal to rhs. - bool operator<= (arg_type rhs) const; - - /// Atomically check if @c value_ less than rhs. - bool operator< (arg_type rhs) const; - - /// Atomically assign rhs to @c value_. - ACE_Atomic_Op_Ex &operator= (arg_type rhs); - - /// Atomically assign to @c value_. - ACE_Atomic_Op_Ex &operator= ( - ACE_Atomic_Op_Ex const & rhs); - - /// Exchange value with @a newval. - TYPE exchange (TYPE newval); - - /// Explicitly return @c value_. - TYPE value (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - /// Manage copying... - ACE_Atomic_Op_Ex (ACE_Atomic_Op_Ex const &); - - /** - * Returns a reference to the underlying ACE_LOCK. This makes it - * possible to acquire the lock explicitly, which can be useful in - * some cases if you instantiate the ACE_Atomic_Op_Ex with an - * ACE_Recursive_Mutex or ACE_Process_Mutex. - * - * @note The right name would be lock_, but HP/C++ will choke on that! - */ - ACE_LOCK & mutex (void); - - /** - * Explicitly return @c value_ (by reference). This gives the user - * full, unrestricted access to the underlying value. This method - * will usually be used in conjunction with explicit access to the - * lock. Use with care ;-) - */ - TYPE & value_i (void); - -private: - /// Type of synchronization mechanism. - ACE_LOCK & mutex_; - - /// Current object decorated by the atomic op. - TYPE value_; -}; - -/** - * @class ACE_Atomic_Op - * - * @brief Transparently parameterizes synchronization into basic - * arithmetic operations. - * - * This class is described in an article in the July/August 1994 - * issue of the C++ Report magazine. It implements a - * templatized version of the Decorator pattern from the GoF book. - * - * Certain platforms may provide a template specialization for - * ACE_Atomic_Op that provides optimized - * atomic integer operations without actually requiring a mutex. - */ -template -class ACE_Atomic_Op -{ -public: - typedef typename ACE_Type_Traits::parameter_type arg_type; - - /// Initialize @c value_ to 0. - ACE_Atomic_Op (void); - - /// Initialize @c value_ to c. - ACE_Atomic_Op (arg_type c); - - /// Manage copying... - ACE_Atomic_Op (ACE_Atomic_Op const & c); - - /// Atomically assign @a rhs to @c value_. - ACE_Atomic_Op & operator= (arg_type rhs); - - /// Atomically assign @a rhs to @c value_. - ACE_Atomic_Op & operator= ( - ACE_Atomic_Op const & rhs); - - /// Atomically pre-increment @c value_. - TYPE operator++ (void); - - /// Atomically post-increment @c value_. - TYPE operator++ (int); - - /// Atomically increment @c value_ by rhs. - TYPE operator+= (arg_type rhs); - - /// Atomically pre-decrement @c value_. - TYPE operator-- (void); - - /// Atomically post-decrement @c value_. - TYPE operator-- (int); - - /// Atomically decrement @c value_ by @a rhs. - TYPE operator-= (arg_type rhs); - - /// Atomically compare @c value_ with @a rhs. - bool operator== (arg_type rhs) const; - - /// Atomically compare @c value_ with @a rhs. - bool operator!= (arg_type rhs) const; - - /// Atomically check if @c value_ greater than or equal to @a rhs. - bool operator>= (arg_type rhs) const; - - /// Atomically check if @c value_ greater than @a rhs. - bool operator> (arg_type rhs) const; - - /// Atomically check if @c value_ less than or equal to @a rhs. - bool operator<= (arg_type rhs) const; - - /// Atomically check if @c value_ less than @a rhs. - bool operator< (arg_type rhs) const; - - /// Exchange value with @a newval. - TYPE exchange (TYPE newval); - - /// Explicitly return @c value_. - TYPE value (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - /** - * Explicitly return @c value_ (by reference). This gives the user - * full, unrestricted access to the underlying value. This method - * will usually be used in conjunction with explicit access to the - * lock. Use with care ;-) - */ - TYPE & value_i (void); - -private: - /// Type of synchronization mechanism. - ACE_LOCK own_mutex_; - - /// Underlying atomic op implementation. - ACE_Atomic_Op_Ex impl_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Atomic_Op_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Atomic_Op_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Atomic_Op_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /*ACE_ATOMIC_OP_T_H*/ diff --git a/deps/acelite/ace/Atomic_Op_T.inl b/deps/acelite/ace/Atomic_Op_T.inl deleted file mode 100644 index 1b1eb988f..000000000 --- a/deps/acelite/ace/Atomic_Op_T.inl +++ /dev/null @@ -1,346 +0,0 @@ -// -*- C++ -*- -#include "ace/Guard_T.h" - -#include - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// -// ACE_Atomic_Op_Ex inline functions -// - -template -ACE_INLINE TYPE -ACE_Atomic_Op_Ex::operator++ (void) -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator++"); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_); - return ++this->value_; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op_Ex::operator+= ( - typename ACE_Atomic_Op_Ex::arg_type rhs) -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator+="); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_); - return this->value_ += rhs; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op_Ex::operator-- (void) -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator--"); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_); - return --this->value_; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op_Ex::operator-= ( - typename ACE_Atomic_Op_Ex::arg_type rhs) -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator-="); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_); - return this->value_ -= rhs; -} - -template -ACE_INLINE -ACE_Atomic_Op_Ex::ACE_Atomic_Op_Ex ( - ACE_Atomic_Op_Ex const & rhs) - : mutex_ (rhs.mutex_) - , value_ (rhs.value ()) // rhs.value() returns atomically -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::ACE_Atomic_Op_Ex"); -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op_Ex::operator++ (int) -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator++"); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_); - return this->value_++; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op_Ex::operator-- (int) -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator--"); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_); - return this->value_--; -} - -template -ACE_INLINE bool -ACE_Atomic_Op_Ex::operator== ( - typename ACE_Atomic_Op_Ex::arg_type rhs) const -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator=="); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false); - return this->value_ == rhs; -} - -template -ACE_INLINE bool -ACE_Atomic_Op_Ex::operator!= ( - typename ACE_Atomic_Op_Ex::arg_type rhs) const -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator!="); - return !(*this == rhs); -} - -template -ACE_INLINE bool -ACE_Atomic_Op_Ex::operator>= ( - typename ACE_Atomic_Op_Ex::arg_type rhs) const -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator>="); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false); - return this->value_ >= rhs; -} - -template -ACE_INLINE bool -ACE_Atomic_Op_Ex::operator> ( - typename ACE_Atomic_Op_Ex::arg_type rhs) const -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator>"); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false); - return this->value_ > rhs; -} - -template -ACE_INLINE bool -ACE_Atomic_Op_Ex::operator<= ( - typename ACE_Atomic_Op_Ex::arg_type rhs) const -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator<="); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false); - return this->value_ <= rhs; -} - -template -ACE_INLINE bool -ACE_Atomic_Op_Ex::operator< ( - typename ACE_Atomic_Op_Ex::arg_type rhs) const -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator<"); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, false); - return this->value_ < rhs; -} - -template -ACE_INLINE ACE_Atomic_Op_Ex & -ACE_Atomic_Op_Ex::operator= ( - ACE_Atomic_Op_Ex const & rhs) -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator="); - - ACE_Atomic_Op_Ex tmp (rhs); - - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, *this); - std::swap (this->value_, tmp.value_); - - return *this; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op_Ex::exchange (TYPE newval) -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::exchange"); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_); - std::swap (this->value_, newval); - return newval; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op_Ex::value (void) const -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::value"); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, this->value_); - return this->value_; -} - -template -ACE_INLINE TYPE & -ACE_Atomic_Op_Ex::value_i (void) -{ - // Explicitly return (by reference). This gives the user - // full, unrestricted access to the underlying value. This method - // will usually be used in conjunction with explicit access to the - // lock. Use with care ;-) - return this->value_; -} - -template -ACE_INLINE ACE_Atomic_Op_Ex & -ACE_Atomic_Op_Ex::operator= ( - typename ACE_Atomic_Op_Ex::arg_type rhs) -{ - // ACE_TRACE ("ACE_Atomic_Op_Ex::operator="); - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, *this); - this->value_ = rhs; - return *this; -} - -// -// ACE_Atomic_Op inline functions -// - -template ACE_INLINE -ACE_Atomic_Op::ACE_Atomic_Op ( - ACE_Atomic_Op const & rhs) - : impl_ (own_mutex_, rhs.value ()) -{ - // ACE_TRACE ("ACE_Atomic_Op::ACE_Atomic_Op"); -} - - -template -ACE_INLINE ACE_Atomic_Op & -ACE_Atomic_Op::operator= ( - typename ACE_Atomic_Op::arg_type i) -{ - this->impl_ = i; - return *this; -} - -template -ACE_INLINE ACE_Atomic_Op & -ACE_Atomic_Op::operator= ( - ACE_Atomic_Op const & rhs) -{ - this->impl_ = rhs.impl_; - return *this; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op::operator++ (void) -{ - return ++this->impl_; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op::operator++ (int) -{ - return this->impl_++; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op::operator+= ( - typename ACE_Atomic_Op::arg_type rhs) -{ - return this->impl_ += rhs; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op::operator-- (void) -{ - return --this->impl_; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op::operator-- (int) -{ - return this->impl_--; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op::operator-= ( - typename ACE_Atomic_Op::arg_type rhs) -{ - return this->impl_ -= rhs; -} - -template -ACE_INLINE bool -ACE_Atomic_Op::operator== ( - typename ACE_Atomic_Op::arg_type rhs) const -{ - return this->impl_ == rhs; -} - -template -ACE_INLINE bool -ACE_Atomic_Op::operator!= ( - typename ACE_Atomic_Op::arg_type rhs) const -{ - return this->impl_ != rhs; -} - -template -ACE_INLINE bool -ACE_Atomic_Op::operator>= ( - typename ACE_Atomic_Op::arg_type rhs) const -{ - return this->impl_ >= rhs; -} - -template -ACE_INLINE bool -ACE_Atomic_Op::operator> ( - typename ACE_Atomic_Op::arg_type rhs) const -{ - return this->impl_ > rhs; -} - -template -ACE_INLINE bool -ACE_Atomic_Op::operator<= ( - typename ACE_Atomic_Op::arg_type rhs) const -{ - return this->impl_ <= rhs; -} - -template -ACE_INLINE bool -ACE_Atomic_Op::operator< ( - typename ACE_Atomic_Op::arg_type rhs) const -{ - return this->impl_ < rhs; -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op::exchange (TYPE newval) -{ - return this->impl_.exchange (newval); -} - -template -ACE_INLINE TYPE -ACE_Atomic_Op::value (void) const -{ - return this->impl_.value (); -} - -template -ACE_INLINE void -ACE_Atomic_Op::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - this->impl_.dump (); -#endif /* ACE_HAS_DUMP */ - return; -} -template -ACE_INLINE TYPE & -ACE_Atomic_Op::value_i (void) -{ - return this->impl_.value_i (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Auto_Event.cpp b/deps/acelite/ace/Auto_Event.cpp deleted file mode 100644 index c95c0e855..000000000 --- a/deps/acelite/ace/Auto_Event.cpp +++ /dev/null @@ -1,54 +0,0 @@ -#include "ace/Auto_Event.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Auto_Event.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Auto_Event_T) - -template -ACE_Auto_Event_T::ACE_Auto_Event_T ( - int initial_state, - int type, - const char *name, - void *arg) - : ACE_Event_T (0, - initial_state, - type, - ACE_TEXT_CHAR_TO_TCHAR (name), - arg) -{ -} - -#if defined (ACE_HAS_WCHAR) -template -ACE_Auto_Event_T::ACE_Auto_Event_T ( - int initial_state, - int type, - const wchar_t *name, - void *arg) - : ACE_Event_T (0, - initial_state, - type, - ACE_TEXT_WCHAR_TO_TCHAR (name), - arg) -{ -} -#endif /* ACE_HAS_WCHAR */ - -template -void -ACE_Auto_Event_T::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_Event_T::dump (); -#endif /* ACE_HAS_DUMP */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Auto_Event.h b/deps/acelite/ace/Auto_Event.h deleted file mode 100644 index f01882c62..000000000 --- a/deps/acelite/ace/Auto_Event.h +++ /dev/null @@ -1,110 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Auto_Event.h - * - * Moved from Synch.h. - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_AUTO_EVENT_H -#define ACE_AUTO_EVENT_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Event.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Auto_Event - * - * @brief Auto Events. - * - * Specialization of Event mechanism which wakes up one waiting - * thread on @c signal. All platforms support process-scope locking - * support. However, only Win32 platforms support global naming and - * system-scope locking support. - */ -template -class ACE_Auto_Event_T : public ACE_Event_T -{ -public: - /// Constructor which will create auto event - ACE_Auto_Event_T (int initial_state = 0, - int type = USYNC_THREAD, - const char *name = 0, - void *arg = 0); - -#if defined (ACE_HAS_WCHAR) - /// Constructor which will create auto event (wchar_t version) - ACE_Auto_Event_T (int initial_state, - int type, - const wchar_t *name, - void *arg = 0); -#endif /* ACE_HAS_WCHAR */ - - /// Default dtor. - virtual ~ACE_Auto_Event_T (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks - ACE_ALLOC_HOOK_DECLARE; -}; - -class ACE_Auto_Event : - public ACE_Auto_Event_T -{ -public: - /// Constructor which will create auto event - ACE_Auto_Event (int initial_state = 0, - int type = USYNC_THREAD, - const char *name = 0, - void *arg = 0) - : ACE_Auto_Event_T (initial_state, type, name, arg) - { - } - -#if defined (ACE_HAS_WCHAR) - /// Constructor which will create auto event (wchar_t version) - ACE_Auto_Event (int initial_state, - int type, - const wchar_t *name, - void *arg = 0) - : ACE_Auto_Event_T (initial_state, type, name, arg) - { - } -#endif /* ACE_HAS_WCHAR */ - - /// Default dtor. - virtual ~ACE_Auto_Event (void) - { - } -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Auto_Event.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Auto_Event.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Auto_Event.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_AUTO_EVENT_H */ diff --git a/deps/acelite/ace/Auto_Event.inl b/deps/acelite/ace/Auto_Event.inl deleted file mode 100644 index 919c048d3..000000000 --- a/deps/acelite/ace/Auto_Event.inl +++ /dev/null @@ -1,10 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_INLINE -ACE_Auto_Event_T::~ACE_Auto_Event_T (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Auto_Functor.cpp b/deps/acelite/ace/Auto_Functor.cpp deleted file mode 100644 index 7310d78d3..000000000 --- a/deps/acelite/ace/Auto_Functor.cpp +++ /dev/null @@ -1,37 +0,0 @@ -#ifndef ACE_AUTO_FUNCTOR_CPP -#define ACE_AUTO_FUNCTOR_CPP - -#include "ace/Auto_Functor.h" - -#if !defined(__ACE_INLINE__) -# include "ace/Auto_Functor.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Utils::Auto_Functor::~Auto_Functor() -{ - reset(0); -} - -template void -ACE_Utils::Auto_Functor::reset(X * p) -{ - if(p_ != 0) - { - f_(p_); - } - p_ = p; -} - -templatevoid -ACE_Utils::Auto_Functor::reset(X * p, Functor f) -{ - reset(p); - f_ = f; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /*ACE_AUTO_FUNCTOR_CPP*/ diff --git a/deps/acelite/ace/Auto_Functor.h b/deps/acelite/ace/Auto_Functor.h deleted file mode 100644 index 7e75ae7b6..000000000 --- a/deps/acelite/ace/Auto_Functor.h +++ /dev/null @@ -1,118 +0,0 @@ -// -*- C++ -*- -//============================================================================= -/** - * @file Auto_Functor.h - * - * @author Carlos O'Ryan - */ -//============================================================================= -#ifndef ACE_AUTO_FUNCTOR_H -#define ACE_AUTO_FUNCTOR_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Global_Macros.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -namespace ACE_Utils -{ -/** - * @class Auto_Functor_Ref - * - * @brief Helper class to implement assignment and copy-construction - * as expected - */ -template -struct Auto_Functor_Ref -{ - X * p_; - Functor f_; - - Auto_Functor_Ref(X * p, Functor f); -}; - -/** - * @class Auto_Functor - * - * @brief Helper template to implement auto_ptr<>-like classes, but - * executing a functor in the destructor, instead of always - * deleting things. - * - * The functor is called in the destructor, and it must implement: - * - * Functor() throw();
- * Functor(Functor const &) throw();
- * Functor & operator=(Functor const &) throw();
- * void operator()(X * p) throw();
- */ -template -class Auto_Functor -{ -public: - typedef X element_type; - typedef Functor functor_type; - - /// Constructor - explicit Auto_Functor (X * p = 0, - Functor functor = Functor()); // throw() - - Auto_Functor (Auto_Functor & rhs); // throw() - - Auto_Functor& operator= (Auto_Functor & rhs); // throw() - - template - Auto_Functor(Auto_Functor& rhs); // throw() - - template - Auto_Functor& operator= (Auto_Functor& rhs); // throw() - - ~Auto_Functor(); // throw() - - X & operator*() const; // throw() - - X * operator->() const; // throw() - - X * get(); // throw() - - X * release(); // throw() - - void reset (X * p = 0); // throw() - - void reset (X * p, Functor f); // throw() - - Functor const & functor() const; // throw() - - Auto_Functor(Auto_Functor_Ref rhs); // throw() - - Auto_Functor & operator=(Auto_Functor_Ref rhs); // throw() - - template operator Auto_Functor_Ref(); // throw() - - template operator Auto_Functor(); // throw() - -private: - X * p_; - - Functor f_; -}; - -} // namespace ACE_Utils - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined(__ACE_INLINE__) -# include "ace/Auto_Functor.inl" -#endif /* __ACE_INLINE__ */ - -#if defined(ACE_TEMPLATES_REQUIRE_SOURCE) -# include "ace/Auto_Functor.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#include /**/ "ace/post.h" -#endif /* ACE_AUTO_FUNCTOR_H*/ diff --git a/deps/acelite/ace/Auto_Functor.inl b/deps/acelite/ace/Auto_Functor.inl deleted file mode 100644 index be0c38361..000000000 --- a/deps/acelite/ace/Auto_Functor.inl +++ /dev/null @@ -1,117 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE -ACE_Utils::Auto_Functor_Ref:: -Auto_Functor_Ref(X * p, Functor f) - : p_(p) - , f_(f) -{ -} - -template ACE_INLINE -ACE_Utils::Auto_Functor::Auto_Functor(X * p, Functor f) - : p_(p) - , f_(f) -{ -} - -template ACE_INLINE -ACE_Utils::Auto_Functor::Auto_Functor(Auto_Functor & rhs) - : p_(rhs.release()) - , f_(rhs.f_) -{ -} - -template -ACE_INLINE ACE_Utils::Auto_Functor& -ACE_Utils::Auto_Functor:: operator=(Auto_Functor & rhs) -{ - reset(rhs.release()); - f_ = rhs.f_; - return *this; -} - -template template ACE_INLINE -ACE_Utils::Auto_Functor::Auto_Functor(Auto_Functor& rhs) - : p_(rhs.release()) - , f_(rhs.f_) -{ -} - -template template -ACE_INLINE ACE_Utils::Auto_Functor& -ACE_Utils::Auto_Functor::operator=(Auto_Functor& rhs) -{ - reset(rhs.release()); - return *this; -} - -template ACE_INLINE X & -ACE_Utils::Auto_Functor::operator*() const -{ - return *p_; -} - -template -ACE_INLINE X * -ACE_Utils::Auto_Functor::operator->() const -{ - return p_; -} - -template -ACE_INLINE X * -ACE_Utils::Auto_Functor::get() -{ - return p_; -} - -template -ACE_INLINE X * -ACE_Utils::Auto_Functor::release() -{ - X * tmp = p_; - p_ = 0; - return tmp; -} - -template -ACE_INLINE Functor const & -ACE_Utils::Auto_Functor::functor() const -{ - return f_; -} - -template ACE_INLINE -ACE_Utils::Auto_Functor::Auto_Functor(Auto_Functor_Ref rhs) - : p_(rhs.p_) - , f_(rhs.f_) -{ -} - -template -ACE_INLINE ACE_Utils::Auto_Functor & -ACE_Utils::Auto_Functor::operator=(Auto_Functor_Ref rhs) -{ - if(rhs.p_ != p_) - { - reset(rhs.p_); - f_ = rhs.f_; - } - return *this; -} - -template template ACE_INLINE -ACE_Utils::Auto_Functor::operator ACE_Utils::Auto_Functor_Ref() -{ - return ACE_Utils::Auto_Functor_Ref(release(), f_); -} - -template template ACE_INLINE -ACE_Utils::Auto_Functor::operator ACE_Utils::Auto_Functor() -{ - return ACE_Utils::Auto_Functor(release(), f_); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Auto_IncDec_T.cpp b/deps/acelite/ace/Auto_IncDec_T.cpp deleted file mode 100644 index 5d408c7db..000000000 --- a/deps/acelite/ace/Auto_IncDec_T.cpp +++ /dev/null @@ -1,36 +0,0 @@ -#ifndef ACE_AUTO_INCDEC_T_CPP -#define ACE_AUTO_INCDEC_T_CPP - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Auto_IncDec_T.h" -#include "ace/Log_Category.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Auto_IncDec_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Auto_IncDec) - -template void -ACE_Auto_IncDec::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Auto_IncDec::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_AUTO_INCDEC_T_CPP */ diff --git a/deps/acelite/ace/Auto_IncDec_T.h b/deps/acelite/ace/Auto_IncDec_T.h deleted file mode 100644 index d8e028344..000000000 --- a/deps/acelite/ace/Auto_IncDec_T.h +++ /dev/null @@ -1,79 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Auto_IncDec_T.h - * - * @author Edan Ayal - */ -//============================================================================= - - -#ifndef ACE_AUTO_INCDEC_T_H -#define ACE_AUTO_INCDEC_T_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Global_Macros.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Auto_IncDec - * - * @brief This class automatically increments and decrements a - * parameterized counter. - * - * This data structure is meant to be used within a method, - * function, or scope. The actual parameter given for the - * @c ACE_SAFELY_INCREMENTABLE_DECREMENTABLE template parameter - * must provide at least operators ++ and --. - */ -template -class ACE_Auto_IncDec -{ -public: - /// Implicitly increment the counter. - ACE_Auto_IncDec (ACE_SAFELY_INCREMENTABLE_DECREMENTABLE &counter); - - /// Implicitly decrement the counter. - ~ACE_Auto_IncDec (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Reference to the @c ACE_SAFELY_INCREMENTABLE_DECREMENTABLE counter - /// we're incrementing/decrementing. - ACE_SAFELY_INCREMENTABLE_DECREMENTABLE &counter_; -private: - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Auto_IncDec &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Auto_IncDec (const ACE_Auto_IncDec &)) -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Auto_IncDec_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Auto_IncDec_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Auto_IncDec_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_AUTO_INCDEC_T_H */ diff --git a/deps/acelite/ace/Auto_IncDec_T.inl b/deps/acelite/ace/Auto_IncDec_T.inl deleted file mode 100644 index cb2144888..000000000 --- a/deps/acelite/ace/Auto_IncDec_T.inl +++ /dev/null @@ -1,22 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Implicitly and automatically increment the counter. - -template ACE_INLINE -ACE_Auto_IncDec::ACE_Auto_IncDec - (ACE_SAFELY_INCREMENTABLE_DECREMENTABLE &counter) - : counter_ (counter) -{ - ++this->counter_; -} - -// Implicitly and automatically decrement the counter. - -template ACE_INLINE -ACE_Auto_IncDec::~ACE_Auto_IncDec (void) -{ - --this->counter_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Auto_Ptr.cpp b/deps/acelite/ace/Auto_Ptr.cpp deleted file mode 100644 index 09028186a..000000000 --- a/deps/acelite/ace/Auto_Ptr.cpp +++ /dev/null @@ -1,21 +0,0 @@ -#ifndef ACE_AUTO_PTR_CPP -#define ACE_AUTO_PTR_CPP - -#include "ace/Auto_Ptr.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/Auto_Ptr.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tt(ACE_Auto_Basic_Ptr) -ACE_ALLOC_HOOK_DEFINE_Tt(ACE_Auto_Basic_Array_Ptr) - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_AUTO_PTR_CPP */ diff --git a/deps/acelite/ace/Auto_Ptr.h b/deps/acelite/ace/Auto_Ptr.h deleted file mode 100644 index 47ad7c397..000000000 --- a/deps/acelite/ace/Auto_Ptr.h +++ /dev/null @@ -1,228 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Auto_Ptr.h - * - * @author Doug Schmidt - * @author Irfan Pyarali - * @author Jack Reeves - * @author Dr. Harald M. Mueller - */ -//============================================================================= - -#ifndef ACE_AUTO_PTR_H -#define ACE_AUTO_PTR_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (_MSC_VER) -// Suppress warning e.g. "return type for -// 'ACE_Auto_Array_Pointer::operator ->' is 'type *' (i.e., not a UDT -// or reference to a UDT. Will produce errors if applied using infix -// notation)" -# pragma warning(push) -# pragma warning(disable: 4284) -#endif /* _MSC_VER */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Auto_Basic_Ptr - * - * @brief Implements the draft C++ standard auto_ptr abstraction. - * This class allows one to work on non-object (basic) types - */ -template -class ACE_Auto_Basic_Ptr -{ -public: - typedef X element_type; - - explicit ACE_Auto_Basic_Ptr (X * p = 0) : p_ (p) {} - - ACE_Auto_Basic_Ptr (ACE_Auto_Basic_Ptr & ap); - ACE_Auto_Basic_Ptr &operator= (ACE_Auto_Basic_Ptr & rhs); - ~ACE_Auto_Basic_Ptr (void); - - // = Accessor methods. - X &operator *() const; - X *get (void) const; - X *release (void); - void reset (X * p = 0); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - X *p_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_HAS_CPP17) -// C++17 has removed std::auto_ptr but this is heavily used -// in ACE and TAO tests so for the moment we are providing -// our own auto_ptr implementation -# define ACE_LACKS_AUTO_PTR -# include -#endif /* ACE_HAS_CPP17 */ - -#if !defined (ACE_LACKS_AUTO_PTR) && \ - defined (ACE_HAS_STANDARD_CPP_LIBRARY) && \ - (ACE_HAS_STANDARD_CPP_LIBRARY != 0) -#include -#if defined (ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB) && \ - (ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB != 0) -using std::auto_ptr; -#endif /* ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB */ -#else /* ACE_HAS_STANDARD_CPP_LIBRARY */ - -/** - * @class auto_ptr - * - * @brief Implements the draft C++ standard auto_ptr abstraction. - */ -template -class auto_ptr : public ACE_Auto_Basic_Ptr -{ -public: - typedef X element_type; - - explicit auto_ptr (X * p = 0) : ACE_Auto_Basic_Ptr (p) {} - auto_ptr (auto_ptr & ap) : ACE_Auto_Basic_Ptr (ap.release ()) {} - - X *operator-> () const; -}; - -#endif /* ACE_HAS_STANDARD_CPP_LIBRARY */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @brief Implements the draft C++ standard auto_ptr abstraction. - * This version can be used instead of auto_ptr - */ -template -class ACE_Auto_Ptr : public ACE_Auto_Basic_Ptr -{ -public: - typedef X element_type; - - explicit ACE_Auto_Ptr (X * p = 0) : ACE_Auto_Basic_Ptr (p) {} - - X *operator-> () const; -}; - -/** - * @class ACE_Auto_Basic_Array_Ptr - * - * @brief Implements an extension to the draft C++ standard auto_ptr - * abstraction. This class allows one to work on non-object - * (basic) types that must be treated as an array, e.g., - * deallocated via "delete [] foo". - */ -template -class ACE_Auto_Basic_Array_Ptr -{ -public: - typedef X element_type; - - explicit ACE_Auto_Basic_Array_Ptr (X * p = 0) : p_ (p) {} - - ACE_Auto_Basic_Array_Ptr (ACE_Auto_Basic_Array_Ptr & ap); - ACE_Auto_Basic_Array_Ptr &operator= (ACE_Auto_Basic_Array_Ptr & rhs); - ~ACE_Auto_Basic_Array_Ptr (void); - - // = Accessor methods. - X & operator* () const; - X & operator[] (int i) const; - X * get (void) const; - X * release (void); - void reset (X * p = 0); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - X * p_; -}; - -/** - * @class ACE_Auto_Array_Ptr - * - * @brief Implements an extension to the draft C++ standard auto_ptr - * abstraction. - */ -template -class ACE_Auto_Array_Ptr : public ACE_Auto_Basic_Array_Ptr -{ -public: - typedef X element_type; - - explicit ACE_Auto_Array_Ptr (X *p = 0) - : ACE_Auto_Basic_Array_Ptr (p) {} - - X *operator-> () const; -}; - - -/** - * @brief Reset given @c auto_ptr element to new element. - * - * Some platforms have an older version of auto_ptr support, which - * lacks reset, and cannot be disabled easily. Portability to these - * platforms requires use of this function template. This function - * template also works for the @c ACE_Auto_{Basic_}Array_Ptr class - * template, as well. - */ -template -inline void -ACE_auto_ptr_reset (AUTO_PTR_TYPE & ap, - PTR_TYPE * p) -{ -#if defined (ACE_AUTO_PTR_LACKS_RESET) - // Allow compiler to adjust pointer to potential base class pointer - // of element type found in auto_ptr. - typename AUTO_PTR_TYPE::element_type * const tp = p; - if (tp != ap.get ()) - { - ap = AUTO_PTR_TYPE (tp); - } -#else - ap.reset (p); -#endif /* ACE_AUTO_PTR_LACKS_RESET */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Auto_Ptr.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Auto_Ptr.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Auto_Ptr.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#if defined (_MSC_VER) -// Restore the warning state to what it was before entry. -# pragma warning(pop) -#endif /* _MSC_VER */ - -#include /**/ "ace/post.h" -#endif /* ACE_AUTO_PTR_H */ diff --git a/deps/acelite/ace/Auto_Ptr.inl b/deps/acelite/ace/Auto_Ptr.inl deleted file mode 100644 index 1cc93536e..000000000 --- a/deps/acelite/ace/Auto_Ptr.inl +++ /dev/null @@ -1,181 +0,0 @@ -// -*- C++ -*- -#include "ace/Global_Macros.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE void -ACE_Auto_Basic_Ptr::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Auto_Basic_Ptr::dump"); -#endif /* ACE_HAS_DUMP */ -} - -template ACE_INLINE void -ACE_Auto_Basic_Array_Ptr::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Auto_Basic_Array_Ptr::dump"); -#endif /* ACE_HAS_DUMP */ -} - -template ACE_INLINE -ACE_Auto_Basic_Ptr::ACE_Auto_Basic_Ptr (ACE_Auto_Basic_Ptr &rhs) - : p_ (rhs.release ()) -{ - ACE_TRACE ("ACE_Auto_Basic_Ptr::ACE_Auto_Basic_Ptr"); -} - -template ACE_INLINE X * -ACE_Auto_Basic_Ptr::get (void) const -{ - ACE_TRACE ("ACE_Auto_Basic_Ptr::get"); - return this->p_; -} - -template ACE_INLINE X * -ACE_Auto_Basic_Ptr::release (void) -{ - ACE_TRACE ("ACE_Auto_Basic_Ptr::release"); - X *old = this->p_; - this->p_ = 0; - return old; -} - -template ACE_INLINE void -ACE_Auto_Basic_Ptr::reset (X *p) -{ - ACE_TRACE ("ACE_Auto_Basic_Ptr::reset"); - if (this->get () != p) - delete this->get (); - this->p_ = p; -} - -template ACE_INLINE ACE_Auto_Basic_Ptr & -ACE_Auto_Basic_Ptr::operator= (ACE_Auto_Basic_Ptr &rhs) -{ - ACE_TRACE ("ACE_Auto_Basic_Ptr::operator="); - if (this != &rhs) - { - this->reset (rhs.release ()); - } - return *this; -} - -template ACE_INLINE -ACE_Auto_Basic_Ptr::~ACE_Auto_Basic_Ptr (void) -{ - ACE_TRACE ("ACE_Auto_Basic_Ptr::~ACE_Auto_Basic_Ptr"); - delete this->get (); -} - -template ACE_INLINE X & -ACE_Auto_Basic_Ptr::operator *() const -{ - ACE_TRACE ("ACE_Auto_Basic_Ptr::operator *()"); - return *this->get (); -} - -#if defined (ACE_LACKS_AUTO_PTR) || \ - !defined (ACE_HAS_STANDARD_CPP_LIBRARY) || \ - (ACE_HAS_STANDARD_CPP_LIBRARY == 0) - -template ACE_INLINE X * -auto_ptr::operator-> () const -{ - ACE_TRACE ("auto_ptr::operator->"); - return this->get (); -} - -#endif /* ACE_HAS_STANDARD_CPP_LIBRARY */ - -template ACE_INLINE X * -ACE_Auto_Ptr::operator-> () const -{ - ACE_TRACE ("ACE_Auto_Ptr::operator->"); - return this->get (); -} - -template ACE_INLINE X * -ACE_Auto_Basic_Array_Ptr::get (void) const -{ - ACE_TRACE ("ACE_Auto_Basic_Array_Ptr::get"); - return this->p_; -} - -template ACE_INLINE X * -ACE_Auto_Basic_Array_Ptr::release (void) -{ - ACE_TRACE ("ACE_Auto_Basic_Array_Ptr::release"); - X *old = this->p_; - this->p_ = 0; - return old; -} - -template ACE_INLINE void -ACE_Auto_Basic_Array_Ptr::reset (X *p) -{ - ACE_TRACE ("ACE_Auto_Basic_Array_Ptr::reset"); - if (this->get () != p) -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(this->get ()); -#else - delete [] this->get (); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - this->p_ = p; -} - -template ACE_INLINE -ACE_Auto_Basic_Array_Ptr::ACE_Auto_Basic_Array_Ptr (ACE_Auto_Basic_Array_Ptr &rhs) - : p_ (rhs.release ()) -{ - ACE_TRACE ("ACE_Auto_Basic_Array_Ptr::ACE_Auto_Basic_Array_Ptr"); -} - -template ACE_INLINE ACE_Auto_Basic_Array_Ptr & -ACE_Auto_Basic_Array_Ptr::operator= (ACE_Auto_Basic_Array_Ptr &rhs) -{ - ACE_TRACE ("ACE_Auto_Basic_Array_Ptr::operator="); - if (this != &rhs) - { - this->reset (rhs.release ()); - } - return *this; -} - -template ACE_INLINE -ACE_Auto_Basic_Array_Ptr::~ACE_Auto_Basic_Array_Ptr (void) -{ - ACE_TRACE ("ACE_Auto_Basic_Array_Ptr::~ACE_Auto_Basic_Array_Ptr"); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(this->get ()); -#else - delete [] this->get (); -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -template ACE_INLINE X & -ACE_Auto_Basic_Array_Ptr::operator *() const -{ - return *this->get (); -} - -template ACE_INLINE X & -ACE_Auto_Basic_Array_Ptr::operator[](int i) const -{ - X *array = this->get (); - return array[i]; -} - -template ACE_INLINE X * -ACE_Auto_Array_Ptr::operator->() const -{ - return this->get (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Barrier.cpp b/deps/acelite/ace/Barrier.cpp deleted file mode 100644 index 9eb706785..000000000 --- a/deps/acelite/ace/Barrier.cpp +++ /dev/null @@ -1,174 +0,0 @@ -#include "ace/Barrier.h" - -#if defined (ACE_HAS_THREADS) - -#if !defined (__ACE_INLINE__) -#include "ace/Barrier.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Guard_T.h" -#include "ace/OS_NS_errno.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if defined (ACE_HAS_DUMP) -# include "ace/Log_Category.h" -#endif /* ACE_HAS_DUMP */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Sub_Barrier) - -void -ACE_Sub_Barrier::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Sub_Barrier::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->barrier_finished_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("running_threads_ = %d\n"), this->running_threads_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Sub_Barrier::ACE_Sub_Barrier (unsigned int count, - ACE_Thread_Mutex &lock, - const ACE_TCHAR *name, - void *arg) - : barrier_finished_ (lock, name, arg), - running_threads_ (count) -{ -// ACE_TRACE ("ACE_Sub_Barrier::ACE_Sub_Barrier"); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Barrier) - -void -ACE_Barrier::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Barrier::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->lock_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("current_generation_ = %d"), this->current_generation_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\ncount_ = %d"), this->count_)); - this->sub_barrier_1_.dump (); - this->sub_barrier_2_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Barrier::ACE_Barrier (unsigned int count, - const ACE_TCHAR *name, - void *arg) - : lock_ (name, (ACE_mutexattr_t *) arg), - current_generation_ (0), - count_ (count), - sub_barrier_1_ (count, lock_, name, arg), - sub_barrier_2_ (count, lock_, name, arg) -{ - ACE_TRACE ("ACE_Barrier::ACE_Barrier"); - this->sub_barrier_[0] = &this->sub_barrier_1_; - this->sub_barrier_[1] = &this->sub_barrier_2_; -} - -int -ACE_Barrier::wait (void) -{ - ACE_TRACE ("ACE_Barrier::wait"); - ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); - - ACE_Sub_Barrier *sbp = - this->sub_barrier_[this->current_generation_]; - - // Check for shutdown... - if (sbp == 0) - { - errno = ESHUTDOWN; - return -1; - } - - int retval = 0; - - if (sbp->running_threads_ == 1) - { - // We're the last running thread, so swap generations and tell - // all the threads waiting on the barrier to continue on their - // way. - sbp->running_threads_ = this->count_; - // Swap generations. - this->current_generation_ = 1 - this->current_generation_; - sbp->barrier_finished_.broadcast (); - } - else - { - --sbp->running_threads_; - - // Block until all the other threads wait(). - while (sbp->running_threads_ != this->count_) - sbp->barrier_finished_.wait (); - - // We're awake and the count has completed. See if it completed - // because all threads hit the barrier, or because the barrier - // was shut down. - if (this->sub_barrier_[this->current_generation_] == 0) - { - errno = ESHUTDOWN; - retval = -1; - } - } - - return retval; -} - -int -ACE_Barrier::shutdown (void) -{ - ACE_TRACE ("ACE_Barrier::shutdown"); - ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); - - ACE_Sub_Barrier *sbp = - this->sub_barrier_[this->current_generation_]; - - // Check for shutdown... - if (sbp == 0) - { - errno = ESHUTDOWN; - return -1; - } - - // Flag the shutdown - this->sub_barrier_[0] = 0; - this->sub_barrier_[1] = 0; - // Tell all the threads waiting on the barrier to continue on their way. - sbp->running_threads_ = this->count_; - sbp->barrier_finished_.broadcast (); - - return 0; -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Barrier) - -ACE_Thread_Barrier::ACE_Thread_Barrier (unsigned int count, - const ACE_TCHAR *name) - : ACE_Barrier (count, name) -{ -// ACE_TRACE ("ACE_Thread_Barrier::ACE_Thread_Barrier"); -} - -void -ACE_Thread_Barrier::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Thread_Barrier::dump"); - ACE_Barrier::dump (); -#endif /* ACE_HAS_DUMP */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_THREADS */ diff --git a/deps/acelite/ace/Barrier.h b/deps/acelite/ace/Barrier.h deleted file mode 100644 index d6efaf2b8..000000000 --- a/deps/acelite/ace/Barrier.h +++ /dev/null @@ -1,190 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Barrier.h - * - * Moved from Synch.h. - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_BARRIER_H -#define ACE_BARRIER_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include /**/ "ace/config-all.h" - -// ACE platform supports some form of threading. -#if !defined (ACE_HAS_THREADS) - -#include "ace/OS_NS_errno.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Barrier - * - * @brief This is a no-op to make ACE "syntactically consistent." - */ -class ACE_Export ACE_Barrier -{ -public: - ACE_Barrier (unsigned int, const ACE_TCHAR * = 0, void * = 0) {} - ~ACE_Barrier (void) {} - int wait (void) { ACE_NOTSUP_RETURN (-1); } - void dump (void) const {} -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#else /* ACE_HAS_THREADS */ - -#include "ace/Condition_Thread_Mutex.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -struct ACE_Export ACE_Sub_Barrier -{ - // = Initialization. - ACE_Sub_Barrier (unsigned int count, - ACE_Thread_Mutex &lock, - const ACE_TCHAR *name = 0, - void *arg = 0); - - ~ACE_Sub_Barrier (void); - - /// True if this generation of the barrier is done. - ACE_Condition_Thread_Mutex barrier_finished_; - - /// Number of threads that are still running. - int running_threads_; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -/** - * @class ACE_Barrier - * - * @brief Implements "barrier synchronization". - * - * This class allows number of threads to synchronize - * their completion of (one round of) a task, which is known as - * "barrier synchronization". After all the threads call - * on the barrier they are all atomically released and can begin a new - * round. - * - * This implementation uses a "sub-barrier generation numbering" - * scheme to avoid overhead and to ensure that all threads wait to - * leave the barrier correct. This code is based on an article from - * SunOpsis Vol. 4, No. 1 by Richard Marejka - * (Richard.Marejka@canada.sun.com). - */ -class ACE_Export ACE_Barrier -{ -public: - /// Initialize the barrier to synchronize @a count threads. - ACE_Barrier (unsigned int count, - const ACE_TCHAR *name = 0, - void *arg = 0); - - /// Default destructor. - ~ACE_Barrier (void); - - /// Block the caller until all @c count threads have called @c wait and - /// then allow all the caller threads to continue in parallel. - /// - /// @retval 0 after successfully waiting for all threads to wait. - /// @retval -1 if an error occurs or the barrier is shut - /// down (@sa shutdown ()). - int wait (void); - - /// Shut the barrier down, aborting the wait of all waiting threads. - /// Any threads waiting on the barrier when it is shut down will return with - /// value -1, errno ESHUTDOWN. - /// - /// @retval 0 for success, -1 if already shut down. - /// - /// @since ACE beta 5.4.9. - int shutdown (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Serialize access to the barrier state. - ACE_Thread_Mutex lock_; - - /// Either 0 or 1, depending on whether we are the first generation - /// of waiters or the next generation of waiters. - int current_generation_; - - /// Total number of threads that can be waiting at any one time. - int count_; - - /** - * We keep two @c sub_barriers, one for the first "generation" of - * waiters, and one for the next "generation" of waiters. This - * efficiently solves the problem of what to do if all the first - * generation waiters don't leave the barrier before one of the - * threads calls wait() again (i.e., starts up the next generation - * barrier). - */ - ACE_Sub_Barrier sub_barrier_1_; - ACE_Sub_Barrier sub_barrier_2_; - ACE_Sub_Barrier *sub_barrier_[2]; - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Barrier &); - ACE_Barrier (const ACE_Barrier &); -}; - -/** - * @class ACE_Thread_Barrier - * - * @brief Implements "barrier synchronization" using ACE_Thread_Mutexes! - * - * This class is just a simple wrapper for ACE_Barrier that - * selects the USYNC_THREAD variant for the locks. - */ -class ACE_Export ACE_Thread_Barrier : public ACE_Barrier -{ -public: - /// Create a Thread_Barrier, passing in the optional @a name. - ACE_Thread_Barrier (unsigned int count, const ACE_TCHAR *name = 0); - - /// Default destructor. - ~ACE_Thread_Barrier (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Barrier.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* !ACE_HAS_THREADS */ - -#include /**/ "ace/post.h" -#endif /* ACE_BARRIER_H */ diff --git a/deps/acelite/ace/Barrier.inl b/deps/acelite/ace/Barrier.inl deleted file mode 100644 index f742deeb6..000000000 --- a/deps/acelite/ace/Barrier.inl +++ /dev/null @@ -1,19 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Sub_Barrier::~ACE_Sub_Barrier (void) -{ -} - -ACE_INLINE -ACE_Barrier::~ACE_Barrier (void) -{ -} - -ACE_INLINE -ACE_Thread_Barrier::~ACE_Thread_Barrier (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Base_Thread_Adapter.cpp b/deps/acelite/ace/Base_Thread_Adapter.cpp deleted file mode 100644 index f965bac12..000000000 --- a/deps/acelite/ace/Base_Thread_Adapter.cpp +++ /dev/null @@ -1,128 +0,0 @@ -#include "ace/Base_Thread_Adapter.h" - -#if !defined (ACE_HAS_INLINED_OSCALLS) -# include "ace/Base_Thread_Adapter.inl" -#endif /* ACE_HAS_INLINED_OSCALLS */ - -#if defined (ACE_HAS_TSS_EMULATION) -# include "ace/OS_NS_Thread.h" -#endif /* ACE_HAS_TSS_EMULATION */ - -#include "ace/Service_Config.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INIT_LOG_MSG_HOOK ACE_Base_Thread_Adapter::init_log_msg_hook_ = 0; -ACE_INHERIT_LOG_MSG_HOOK ACE_Base_Thread_Adapter::inherit_log_msg_hook_ = 0; -ACE_CLOSE_LOG_MSG_HOOK ACE_Base_Thread_Adapter::close_log_msg_hook_ = 0; -ACE_SYNC_LOG_MSG_HOOK ACE_Base_Thread_Adapter::sync_log_msg_hook_ = 0; -ACE_THR_DESC_LOG_MSG_HOOK ACE_Base_Thread_Adapter::thr_desc_log_msg_hook_ = 0; - -ACE_Base_Thread_Adapter::ACE_Base_Thread_Adapter ( - ACE_THR_FUNC user_func, - void *arg, - ACE_THR_C_FUNC entry_point, - ACE_OS_Thread_Descriptor *td -#if defined (ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS) - , ACE_SEH_EXCEPT_HANDLER selector - , ACE_SEH_EXCEPT_HANDLER handler -#endif /* ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS */ - , long cancel_flags - ) - : user_func_ (user_func) - , arg_ (arg) - , entry_point_ (entry_point) - , thr_desc_ (td) - , ctx_ (ACE_Service_Config::current()) - , flags_ (cancel_flags) -{ - ACE_OS_TRACE ("ACE_Base_Thread_Adapter::ACE_Base_Thread_Adapter"); - - if (ACE_Base_Thread_Adapter::init_log_msg_hook_ != 0) - (*ACE_Base_Thread_Adapter::init_log_msg_hook_) ( - this->log_msg_attributes_ -# if defined (ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS) - , selector - , handler -# endif /* ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS */ - ); -#ifdef ACE_USES_GPROF - getitimer (ITIMER_PROF, &itimer_); -#endif // ACE_USES_GPROF -} - -ACE_Base_Thread_Adapter::~ACE_Base_Thread_Adapter (void) -{ -} - -void -ACE_Base_Thread_Adapter::inherit_log_msg (void) -{ - if (ACE_Base_Thread_Adapter::inherit_log_msg_hook_ != 0) - (*ACE_Base_Thread_Adapter::inherit_log_msg_hook_)( - this->thr_desc_, - this->log_msg_attributes_); - - // Initialize the proper configuration context for the new thread - // Placed here since inherit_log_msg() gets called from any of our - // descendants (before self-destructing) - ACE_Service_Config::current (this->ctx_); -} - -void -ACE_Base_Thread_Adapter::close_log_msg (void) -{ - if (ACE_Base_Thread_Adapter::close_log_msg_hook_ != 0) - (*ACE_Base_Thread_Adapter::close_log_msg_hook_) (); -} - -void -ACE_Base_Thread_Adapter::sync_log_msg (const ACE_TCHAR *prg) -{ - if (ACE_Base_Thread_Adapter::sync_log_msg_hook_ != 0) - (*ACE_Base_Thread_Adapter::sync_log_msg_hook_) (prg); -} - -ACE_OS_Thread_Descriptor::~ACE_OS_Thread_Descriptor (void) -{ -} - -ACE_OS_Thread_Descriptor * -ACE_Base_Thread_Adapter::thr_desc_log_msg (void) -{ - if (ACE_Base_Thread_Adapter::thr_desc_log_msg_hook_ != 0) - return (*ACE_Base_Thread_Adapter::thr_desc_log_msg_hook_) (); - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -// Run the thread entry point for the . This must -// be an extern "C" to make certain compilers happy... - -extern "C" ACE_THR_FUNC_RETURN -ACE_THREAD_ADAPTER_NAME (void *args) -{ - ACE_OS_TRACE ("ACE_THREAD_ADAPTER_NAME"); - -#if defined (ACE_HAS_TSS_EMULATION) - // As early as we can in the execution of the new thread, allocate - // its local TS storage. Allocate it on the stack, to save dynamic - // allocation/dealloction. - void *ts_storage[ACE_TSS_Emulation::ACE_TSS_THREAD_KEYS_MAX]; - ACE_TSS_Emulation::tss_open (ts_storage); -#endif /* ACE_HAS_TSS_EMULATION */ - - ACE_Base_Thread_Adapter * const thread_args = - static_cast (args); - -#ifdef ACE_USES_GPROF - setitimer (ITIMER_PROF, thread_args->timerval (), 0); -#endif // ACE_USES_GPROF - - // Invoke the user-supplied function with the args. - ACE_THR_FUNC_RETURN status = thread_args->invoke (); - - return status; -} - diff --git a/deps/acelite/ace/Base_Thread_Adapter.h b/deps/acelite/ace/Base_Thread_Adapter.h deleted file mode 100644 index e98df29a2..000000000 --- a/deps/acelite/ace/Base_Thread_Adapter.h +++ /dev/null @@ -1,196 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Base_Thread_Adapter.h - * - * @author Nanbor Wang - */ -//============================================================================= - -#ifndef ACE_BASE_THREAD_ADAPTER_H -#define ACE_BASE_THREAD_ADAPTER_H -#include /**/ "ace/pre.h" - -#include "ace/OS_Log_Msg_Attributes.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include /**/ "ace/ACE_export.h" -#include "ace/OS_Log_Msg_Attributes.h" - -#ifdef ACE_USES_GPROF -#include "os_include/sys/os_time.h" -#endif // ACE_USES_GPROF - -#if (defined (ACE_HAS_VERSIONED_NAMESPACE) && ACE_HAS_VERSIONED_NAMESPACE == 1) -# define ACE_THREAD_ADAPTER_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ace_thread_adapter) -#else -# define ACE_THREAD_ADAPTER_NAME ace_thread_adapter -#endif /* ACE_HAS_VERSIONED_NAMESPACE == 1 */ - -/// Run the thread entry point for the ACE_Thread_Adapter. This must -/// be an extern "C" to make certain compilers happy... -extern "C" ACE_Export ACE_THR_FUNC_RETURN ACE_THREAD_ADAPTER_NAME (void *args); - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_OS_Thread_Descriptor - * - * @brief Parent class of all ACE_Thread_Descriptor classes. - * - * Container for ACE_Thread_Descriptor members that are - * used in ACE_OS. - */ -class ACE_Export ACE_OS_Thread_Descriptor -{ -public: - /// Get the thread creation flags. - long flags (void) const; - - virtual ~ACE_OS_Thread_Descriptor (void); - -protected: - /// For use by ACE_Thread_Descriptor. - ACE_OS_Thread_Descriptor (long flags = 0); - - /** - * Keeps track of whether this thread was created "detached" or not. - * If a thread is *not* created detached then if someone calls - * ACE_Thread_Manager::wait(), we need to join with that thread (and - * close down the handle). - */ - long flags_; -}; - -class ACE_Service_Gestalt; - -/** - * @class ACE_Base_Thread_Adapter - * - * @brief Base class for all the Thread_Adapters. - * - * Converts a C++ function into a function that can be - * called from a thread creation routine - * (e.g., pthread_create() or _beginthreadex()) that expects an - * extern "C" entry point. This class also makes it possible to - * transparently provide hooks to register a thread with an - * ACE_Thread_Manager. - * This class is used in ACE_OS::thr_create(). In general, the - * thread that creates an object of this class is different from - * the thread that calls @c invoke() on this object. Therefore, - * the @c invoke() method is responsible for deleting itself. - */ -class ACE_Export ACE_Base_Thread_Adapter -{ -public: - virtual ~ACE_Base_Thread_Adapter (void); - - /// Virtual method invoked by the thread entry point. - virtual ACE_THR_FUNC_RETURN invoke (void) = 0; - - /// Accessor for the C entry point function to the OS thread creation - /// routine. - ACE_THR_C_FUNC entry_point (void); - -#ifdef ACE_USES_GPROF - /// Accessor to the itimer_ - /// followed http://sam.zoy.org/writings/programming/gprof.html - struct itimerval* timerval (void); -#endif // ACE_USES_PROF - - /// Invoke the close_log_msg_hook, if it is present - static void close_log_msg (void); - - /// Invoke the sync_log_msg_hook, if it is present - static void sync_log_msg (const ACE_TCHAR *prog_name); - - /// Invoke the thr_desc_log_msg_hook, if it is present - static ACE_OS_Thread_Descriptor *thr_desc_log_msg (void); - -protected: - /// Constructor. - ACE_Base_Thread_Adapter (ACE_THR_FUNC user_func, - void *arg, - ACE_THR_C_FUNC entry_point = (ACE_THR_C_FUNC) ACE_THREAD_ADAPTER_NAME, - ACE_OS_Thread_Descriptor *td = 0 -# if defined (ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS) - , ACE_SEH_EXCEPT_HANDLER selector = 0 - , ACE_SEH_EXCEPT_HANDLER handler = 0 -# endif /* ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS */ - , long cancel_flags = 0 - ); - /// Inherit the logging features if the parent thread has an - /// ACE_Log_Msg. - void inherit_log_msg (void); - -private: - /// The hooks to inherit and cleanup the Log_Msg attributes - static ACE_INIT_LOG_MSG_HOOK init_log_msg_hook_; - static ACE_INHERIT_LOG_MSG_HOOK inherit_log_msg_hook_; - static ACE_CLOSE_LOG_MSG_HOOK close_log_msg_hook_; - static ACE_SYNC_LOG_MSG_HOOK sync_log_msg_hook_; - static ACE_THR_DESC_LOG_MSG_HOOK thr_desc_log_msg_hook_; - - /// Set the Log_Msg hooks - static void set_log_msg_hooks (ACE_INIT_LOG_MSG_HOOK init_hook, - ACE_INHERIT_LOG_MSG_HOOK inherit_hook, - ACE_CLOSE_LOG_MSG_HOOK close_hook, - ACE_SYNC_LOG_MSG_HOOK sync_hook, - ACE_THR_DESC_LOG_MSG_HOOK thr_desc); - - /// Allow the ACE_Log_Msg class to set its hooks. - friend class ACE_Log_Msg; - -protected: - /// Thread startup function passed in by the user (C++ linkage). - ACE_THR_FUNC user_func_; - - /// Argument to thread startup function. - void *arg_; - - /// Entry point to the underlying OS thread creation call (C - /// linkage). - ACE_THR_C_FUNC entry_point_; - - /** - * Optional thread descriptor. Passing this pointer in will force - * the spawned thread to cache this location in Log_Msg and wait - * until Thread_Manager fills in all information in thread - * descriptor. - */ - ACE_OS_Thread_Descriptor *thr_desc_; - - /// The ACE_Log_Msg attributes. - ACE_OS_Log_Msg_Attributes log_msg_attributes_; - - /// That is useful for gprof, define itimerval -#ifdef ACE_USES_GPROF - struct itimerval itimer_; -#endif // ACE_USES_GPROF - - /// Keep a reference to the configuration context that spawns the - /// thread so the child can inherit it. - ACE_Service_Gestalt * const ctx_; - - /// Pass through the thread-creation flags that can only be acted on by - /// the spawned thread. Currently this is only the cancellation-related - /// flags. - long flags_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -# if defined (ACE_HAS_INLINED_OSCALLS) -# if defined (ACE_INLINE) -# undef ACE_INLINE -# endif /* ACE_INLINE */ -# define ACE_INLINE inline -# include "ace/Base_Thread_Adapter.inl" -# endif /* ACE_HAS_INLINED_OSCALLS */ - -#include /**/ "ace/post.h" -#endif /* ACE_BASE_THREAD_ADAPTER_H */ diff --git a/deps/acelite/ace/Base_Thread_Adapter.inl b/deps/acelite/ace/Base_Thread_Adapter.inl deleted file mode 100644 index febce6f49..000000000 --- a/deps/acelite/ace/Base_Thread_Adapter.inl +++ /dev/null @@ -1,45 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE long -ACE_OS_Thread_Descriptor::flags (void) const -{ - return flags_; -} - -ACE_INLINE -ACE_OS_Thread_Descriptor::ACE_OS_Thread_Descriptor (long flags) - : flags_ (flags) -{ -} - -ACE_INLINE void -ACE_Base_Thread_Adapter::set_log_msg_hooks ( - ACE_INIT_LOG_MSG_HOOK init_hook, - ACE_INHERIT_LOG_MSG_HOOK inherit_hook, - ACE_CLOSE_LOG_MSG_HOOK close_hook, - ACE_SYNC_LOG_MSG_HOOK sync_hook, - ACE_THR_DESC_LOG_MSG_HOOK thr_desc_hook) -{ - ACE_Base_Thread_Adapter::init_log_msg_hook_ = init_hook; - ACE_Base_Thread_Adapter::inherit_log_msg_hook_ = inherit_hook; - ACE_Base_Thread_Adapter::close_log_msg_hook_ = close_hook; - ACE_Base_Thread_Adapter::sync_log_msg_hook_ = sync_hook; - ACE_Base_Thread_Adapter::thr_desc_log_msg_hook_ = thr_desc_hook; -} - -ACE_INLINE ACE_THR_C_FUNC -ACE_Base_Thread_Adapter::entry_point (void) -{ - return this->entry_point_; -} - -#ifdef ACE_USES_GPROF -ACE_INLINE itimerval* -ACE_Base_Thread_Adapter::timerval (void) -{ - return &(this->itimer_); -} -#endif // ACE_USES_GPROF - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Based_Pointer_Repository.cpp b/deps/acelite/ace/Based_Pointer_Repository.cpp deleted file mode 100644 index 6ec16f555..000000000 --- a/deps/acelite/ace/Based_Pointer_Repository.cpp +++ /dev/null @@ -1,123 +0,0 @@ -#include "ace/Map_Manager.h" -#include "ace/Based_Pointer_Repository.h" -#include "ace/Guard_T.h" -#include "ace/Null_Mutex.h" -#include "ace/Synch_Traits.h" -#include "ace/RW_Thread_Mutex.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Based_Pointer_Repository_Rep - * - * @brief Implementation for the ACE_Based_Pointer_Repository. - * - * Every memory pool in ACE binds it's mapping base address and - * the mapped size to this repository every time it maps/remaps a - * new chunk of memory successfully. - */ -class ACE_Based_Pointer_Repository_Rep -{ -public: - // Useful typedefs. - typedef ACE_Map_Manager MAP_MANAGER; - typedef ACE_Map_Iterator MAP_ITERATOR; - typedef ACE_Map_Entry MAP_ENTRY; - - /// Keeps track of the mapping between addresses and their associated - /// values. - MAP_MANAGER addr_map_; - - /// Synchronize concurrent access to the map. - ACE_SYNCH_MUTEX lock_; - - ACE_ALLOC_HOOK_DECLARE; -}; - -ACE_ALLOC_HOOK_DEFINE(ACE_Based_Pointer_Repository_Rep); - -ACE_Based_Pointer_Repository::ACE_Based_Pointer_Repository (void) -{ - ACE_TRACE ("ACE_Based_Pointer_Repository::ACE_Based_Pointer_Repository"); - ACE_NEW (this->rep_, - ACE_Based_Pointer_Repository_Rep); -} - -ACE_Based_Pointer_Repository::~ACE_Based_Pointer_Repository (void) -{ - ACE_TRACE ("ACE_Based_Pointer_Repository::~ACE_Based_Pointer_Repository"); - delete this->rep_; -} - -// Search for appropriate base address in repository - -int -ACE_Based_Pointer_Repository::find (void *addr, void *&base_addr) -{ - ACE_TRACE ("ACE_Based_Pointer_Repository::find"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->rep_->lock_, -1); - ACE_Based_Pointer_Repository_Rep::MAP_ENTRY *ce = 0; - - for (ACE_Based_Pointer_Repository_Rep::MAP_ITERATOR iter (this->rep_->addr_map_); - iter.next (ce) != 0; - iter.advance ()) - // Check to see if is within any of the regions. - if (addr >= ce->ext_id_ - && addr < ((char *)ce->ext_id_ + ce->int_id_)) - { - // Assign the base address. - base_addr = ce->ext_id_; - return 1; - } - - // Assume base address 0 (e.g., if new'ed). - base_addr = 0; - return 0; -} - -// Bind a new entry to the repository or update the size of an -// existing entry. - -int -ACE_Based_Pointer_Repository::bind (void *addr, size_t size) -{ - ACE_TRACE ("ACE_Based_Pointer_Repository::bind"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->rep_->lock_, -1); - - return this->rep_->addr_map_.rebind (addr, size); -} - -// Unbind a base from the repository. - -int -ACE_Based_Pointer_Repository::unbind (void *addr) -{ - ACE_TRACE ("ACE_Based_Pointer_Repository::unbind"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, mon, this->rep_->lock_, -1); - ACE_Based_Pointer_Repository_Rep::MAP_ENTRY *ce = 0; - - // Search for service handlers that requested notification. - - for (ACE_Based_Pointer_Repository_Rep::MAP_ITERATOR iter (this->rep_->addr_map_); - iter.next (ce) != 0; - iter.advance ()) - { - // Check to see if is within any of the regions and if - // so, unbind the key from the map. - if (addr >= ce->ext_id_ - && addr < ((char *)ce->ext_id_ + ce->int_id_)) - // Unbind base address. - return this->rep_->addr_map_.unbind (ce->ext_id_); - } - - return 0; -} - -ACE_SINGLETON_TEMPLATE_INSTANTIATE(ACE_Singleton, ACE_Based_Pointer_Repository, ACE_SYNCH_RW_MUTEX); - - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Based_Pointer_Repository.h b/deps/acelite/ace/Based_Pointer_Repository.h deleted file mode 100644 index 8139a8edb..000000000 --- a/deps/acelite/ace/Based_Pointer_Repository.h +++ /dev/null @@ -1,90 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Based_Pointer_Repository.h - * - * @author Dietrich Quehl - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_BASED_POINTER_REPOSITORY_H -#define ACE_BASED_POINTER_REPOSITORY_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Singleton.h" -#include "ace/Synch_Traits.h" -#include "ace/os_include/os_stddef.h" - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward decl., using the "Cheshire Cat" technique. -class ACE_Based_Pointer_Repository_Rep; - -/** - * @class ACE_Based_Pointer_Repository - * - * @brief Maps pointers to the base address of the region to which each - * pointer belongs. - */ -class ACE_Export ACE_Based_Pointer_Repository -{ -public: - // = Use ACE_Null_Mutex to allow locking while iterating. - - ACE_Based_Pointer_Repository (void); - ~ACE_Based_Pointer_Repository (void); - - // = Search structure methods. - /** - * Return the appropriate @a base_addr region that contains @a addr. - * Returns 1 on success and 0 if the @a addr isn't contained in any - * @a base_addr region. - */ - int find (void *addr, - void *&base_addr); - - /// Bind a new entry to the repository or update the size of an - /// existing entry. Returns 0 on success and -1 on failure. - int bind (void *addr, - size_t size); - - /// Unbind from the repository the that @a addr is - /// contained within. - int unbind (void *addr); - -private: - /// Use the "Cheshire-Cat" technique to hide the implementation in - /// order to avoid circular #include dependencies. - ACE_Based_Pointer_Repository_Rep *rep_; - -private: - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Based_Pointer_Repository &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Based_Pointer_Repository (const ACE_Based_Pointer_Repository &)) -}; - -// ---------------------------------- - -/// Declare a process wide singleton -ACE_SINGLETON_DECLARE (ACE_Singleton, - ACE_Based_Pointer_Repository, - ACE_SYNCH_RW_MUTEX) - -/// Provide a Singleton access point to the based pointer repository. -typedef ACE_Singleton - ACE_BASED_POINTER_REPOSITORY; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#endif /* ACE_BASED_POINTER_REPOSITORY_H */ diff --git a/deps/acelite/ace/Based_Pointer_T.cpp b/deps/acelite/ace/Based_Pointer_T.cpp deleted file mode 100644 index df983903c..000000000 --- a/deps/acelite/ace/Based_Pointer_T.cpp +++ /dev/null @@ -1,121 +0,0 @@ -#ifndef ACE_BASED_POINTER_T_CPP -#define ACE_BASED_POINTER_T_CPP - -#include "ace/Based_Pointer_T.h" -#include "ace/Based_Pointer_Repository.h" -#include "ace/Log_Category.h" - -# define ACE_TRACEX(X) ACE_Trace ____ (ACE_TEXT (X), __LINE__, ACE_TEXT (__FILE__)) - -#if !defined (__ACE_INLINE__) -#include "ace/Based_Pointer_T.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Based_Pointer_Basic) - -template -ACE_Based_Pointer::ACE_Based_Pointer (void) -{ - ACE_TRACE ("ACE_Based_Pointer::ACE_Based_Pointer"); -} - -template void -ACE_Based_Pointer_Basic::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Based_Pointer_Basic::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\ntarget_ = %d\n"), this->target_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("base_offset_ = %d\n"), this->base_offset_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("computed pointer = %x\n"), - (CONCRETE *)(ACE_COMPUTE_BASED_POINTER (this)))); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Based_Pointer::ACE_Based_Pointer (CONCRETE *initial) - : ACE_Based_Pointer_Basic (initial) -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::ACE_Based_Pointer_Basic"); -} - -template -ACE_Based_Pointer::ACE_Based_Pointer (const void* base_addr, int) - : ACE_Based_Pointer_Basic (base_addr, 0) -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::ACE_Based_Pointer_Basic"); -} - -template -ACE_Based_Pointer_Basic::ACE_Based_Pointer_Basic (void) - : target_ (0), - base_offset_ (0) -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::ACE_Based_Pointer_Basic"); - void *base_addr = 0; - - // Find the base address associated with our pointer. Note - // that it's ok for to return 0, which simply indicates that - // the address is not in memory-mapped virtual address space. - ACE_BASED_POINTER_REPOSITORY::instance ()->find (this, - base_addr); - this->base_offset_ = (char *) this - (char *) base_addr; -} - -template -ACE_Based_Pointer_Basic::ACE_Based_Pointer_Basic (const void *base_addr, int) - : target_ (0), - base_offset_ (0) -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::ACE_Based_Pointer_Basic"); - this->base_offset_ = (char *) this - (char *) base_addr; -} - -template -ACE_Based_Pointer_Basic::ACE_Based_Pointer_Basic (CONCRETE *rhs) - : target_ (0), - base_offset_ (0) -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::ACE_Based_Pointer_Basic"); - - if (rhs == 0) - // Store a value of that indicate "NULL" pointer. - this->target_ = -1; - else - { - void *base_addr = 0; - - // Find the base address associated with the pointer. - // Note that it's ok for to return 0, which simply - // indicates that the address is not in memory-mapped virtual - // address space. - ACE_BASED_POINTER_REPOSITORY::instance ()->find (this, - base_addr); - this->base_offset_ = (char *) this - (char *) base_addr; - this->target_ = ((char *) rhs - (char *) base_addr); - } -} - -template -ACE_Based_Pointer_Basic::ACE_Based_Pointer_Basic (const ACE_Based_Pointer_Basic &) -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::ACE_Based_Pointer_Basic"); - - ACE_ASSERT (0); // not implemented. -} - -template -ACE_Based_Pointer::ACE_Based_Pointer (const ACE_Based_Pointer &rhs) - : ACE_Based_Pointer_Basic (rhs) -{ - ACE_TRACE ("ACE_Based_Pointer::ACE_Based_Pointer"); - ACE_ASSERT (0); // not implemented. -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_BASED_POINTER_T_CPP */ diff --git a/deps/acelite/ace/Based_Pointer_T.h b/deps/acelite/ace/Based_Pointer_T.h deleted file mode 100644 index 71432eb1e..000000000 --- a/deps/acelite/ace/Based_Pointer_T.h +++ /dev/null @@ -1,202 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Based_Pointer_T.h - * - * @author Dietrich Quehl - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_BASED_POINTER_T_H -#define ACE_BASED_POINTER_T_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" -#include "ace/Basic_Types.h" - -#if defined (_MSC_VER) -// Suppress warning e.g. "return type for -// 'ACE_Based_Pointer::operator ->' is 'long *' (i.e., not a UDT -// or reference to a UDT. Will produce errors if applied using infix -// notation)" -#pragma warning(disable: 4284) -#endif /* _MSC_VER */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Based_Pointer_Basic - * - * @brief A proxy that keeps track of the relative offset of a "pointer" - * from its base address. - * This class makes it possible to transparently use "pointers" in - * shared memory as easily as programming with pointers to local - * memory. In particular, we don't need to ensure that the base - * addresses of all the pointers are mapped into separate - * processes at the same absolute memory base address. - */ -template -class ACE_Based_Pointer_Basic -{ -public: - /** - * This constructor initializes the by asking the - * Singleton for the base address of - * the memory region within which it is instantiated. Two results - * are possible: - * - * 1. An has stored a base address/size pair and the - * new based-pointer instance is located between the base address and - * the base address + size - 1. In this case, the repository - * returns the base address. - * - * 2. No suitable address/size pair was found. The repository - * assumes an address in the regular (not mapped) virtual address - * space of the process and returns 0. In this case, the - * based-pointer uses its address as an offset to it's base - * address 0. - */ - ACE_Based_Pointer_Basic (void); - - /** - * Initialize this object using the @a initial pointer. This - * constructor initializes the by asking the - * Singleton for the base address of - * the memory region within which it is instantiated. Three results - * are possible: - * - * 1. An has stored a base address/size pair and the - * new based-pointer instance is located between the base address and - * the base address + size - 1. In this case, the repository - * returns the base address. - * - * 2. No suitable address/size pair was found. The repository - * assumes an address in the regular (not mapped) virtual address - * space of the process and returns 0. In this case, the - * based-pointer uses its address as an offset to its base - * address 0. - * - * 3. If @a initial is 0 then set the value of to -1, which - * indicates a "NULL" pointer. - */ - ACE_Based_Pointer_Basic (CONCRETE *initial); - - /// Copy constructor. - ACE_Based_Pointer_Basic (const ACE_Based_Pointer_Basic &); - - /// Constructor for know base address. @a o is only used to - /// resolve overload ambiguity. - ACE_Based_Pointer_Basic (const void *base_addr, int o); - - /// Pseudo-assignment operator. - void operator = (CONCRETE *from); - - /// Pseudo-assignment operator. - void operator = (const ACE_Based_Pointer_Basic &); - - /// Dereference operator. - CONCRETE operator * (void) const; - - /// Less than operator. - bool operator < (const ACE_Based_Pointer_Basic &) const; - - /// Less than or equal operator. - bool operator <= (const ACE_Based_Pointer_Basic &) const; - - /// Greater than operator. - bool operator > (const ACE_Based_Pointer_Basic &) const; - - /// Greater than or equal operator. - bool operator >= (const ACE_Based_Pointer_Basic &) const; - - /// Equality operator. - bool operator == (const ACE_Based_Pointer_Basic &) const; - - /// Inequality operator. - bool operator != (const ACE_Based_Pointer_Basic &) const; - - /// Subscript operator. - CONCRETE operator [](int index) const; - - /// Increment operator. - void operator+= (int index); - - /// Returns the underlying memory address of the smart pointer. - operator CONCRETE *() const; - - /// Returns the underlying memory address of the smart pointer. - CONCRETE *addr (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - /// Dump the state of the object. - void dump (void) const; - -protected: - ptrdiff_t target_; - - /// Keep track of our offset from the base pointer. - ptrdiff_t base_offset_; -}; - -/** - * @class ACE_Based_Pointer - * - * @brief A smart proxy that keeps track of the relative offset of a - * "pointer" from its base address. - * - * This class makes it possible to transparently use "pointers" in - * shared memory as easily as programming with pointers to local - * memory by overloading the C++ delegation operator ->(). - */ -template -class ACE_Based_Pointer : public ACE_Based_Pointer_Basic -{ -public: - /// Constructor. See constructor for ACE_Based_Pointer_Basic for - /// details. - ACE_Based_Pointer (void); - - /// Initialize this object using the pointer. See - /// constructor for ACE_Based_Pointer_Basic for details. - ACE_Based_Pointer (CONCRETE *initial); - - /// Initialize this object with known @a base_addr. @a dummy is - /// a dummy value used to resolve overload ambiguity and it - /// otherwise ignored. - ACE_Based_Pointer (const void *base_addr, int dummy); - - /// Copy constructor (not implemented yet). - ACE_Based_Pointer (const ACE_Based_Pointer &); - - /// Assignment operator. - void operator = (const ACE_Based_Pointer &); - - /// Pseudo-assignment operator. - void operator = (CONCRETE *from); - - /// The C++ "delegation operator". - CONCRETE *operator-> (void); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Based_Pointer_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Based_Pointer_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Based_Pointer_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_BASED_POINTER_T_H */ diff --git a/deps/acelite/ace/Based_Pointer_T.inl b/deps/acelite/ace/Based_Pointer_T.inl deleted file mode 100644 index 04ab75831..000000000 --- a/deps/acelite/ace/Based_Pointer_T.inl +++ /dev/null @@ -1,136 +0,0 @@ -// -*- C++ -*- -#define ACE_COMPUTE_BASED_POINTER(P) (((char *) (P) - (P)->base_offset_) + (P)->target_) -#include "ace/Global_Macros.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE CONCRETE * -ACE_Based_Pointer::operator->(void) -{ - ACE_TRACE ("ACE_Based_Pointer::operator->"); - return reinterpret_cast (ACE_COMPUTE_BASED_POINTER (this)); -} - -template ACE_INLINE void -ACE_Based_Pointer_Basic::operator = (CONCRETE *rhs) -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::operator ="); - if (rhs == 0) - // Store a value of that indicate "NULL" pointer. - this->target_ = -1; - else - this->target_ = ((char *) rhs - - ((char *) this - this->base_offset_)); -} - -template ACE_INLINE void -ACE_Based_Pointer::operator = (CONCRETE *rhs) -{ - ACE_TRACE ("ACE_Based_Pointer::operator ="); - if (rhs == 0) - // Store a value of that indicate "NULL" pointer. - this->target_ = -1; - else - this->target_ = ((char *) rhs - - ((char *) this - this->base_offset_)); -} - -template ACE_INLINE CONCRETE -ACE_Based_Pointer_Basic::operator *(void) const -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::operator *"); - return *reinterpret_cast (ACE_COMPUTE_BASED_POINTER (this)); -} - -template ACE_INLINE CONCRETE * -ACE_Based_Pointer_Basic::addr (void) const -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::addr"); - - if (this->target_ == -1) - return 0; - else - return reinterpret_cast (ACE_COMPUTE_BASED_POINTER (this)); -} - -template ACE_INLINE -ACE_Based_Pointer_Basic::operator CONCRETE *() const -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::operator CONCRETE *()"); - - return this->addr (); -} - -template ACE_INLINE CONCRETE -ACE_Based_Pointer_Basic::operator [] (int index) const -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::operator []"); - CONCRETE *c = - reinterpret_cast (ACE_COMPUTE_BASED_POINTER (this)); - return c[index]; -} - -template ACE_INLINE void -ACE_Based_Pointer_Basic::operator += (int index) -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::operator +="); - this->base_offset_ += (index * sizeof (CONCRETE)); -} - -template ACE_INLINE bool -ACE_Based_Pointer_Basic::operator == (const ACE_Based_Pointer_Basic &rhs) const -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::operator =="); - return ACE_COMPUTE_BASED_POINTER (this) == ACE_COMPUTE_BASED_POINTER (&rhs); -} - -template ACE_INLINE bool -ACE_Based_Pointer_Basic::operator != (const ACE_Based_Pointer_Basic &rhs) const -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::operator !="); - return !(*this == rhs); -} - -template ACE_INLINE bool -ACE_Based_Pointer_Basic::operator < (const ACE_Based_Pointer_Basic &rhs) const -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::operator <"); - return ACE_COMPUTE_BASED_POINTER (this) < ACE_COMPUTE_BASED_POINTER (&rhs); -} - -template ACE_INLINE bool -ACE_Based_Pointer_Basic::operator <= (const ACE_Based_Pointer_Basic &rhs) const -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::operator <="); - return ACE_COMPUTE_BASED_POINTER (this) <= ACE_COMPUTE_BASED_POINTER (&rhs); -} - -template ACE_INLINE bool -ACE_Based_Pointer_Basic::operator > (const ACE_Based_Pointer_Basic &rhs) const -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::operator >"); - return ACE_COMPUTE_BASED_POINTER (this) > ACE_COMPUTE_BASED_POINTER (&rhs); -} - -template ACE_INLINE bool -ACE_Based_Pointer_Basic::operator >= (const ACE_Based_Pointer_Basic &rhs) const -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::operator >="); - return ACE_COMPUTE_BASED_POINTER (this) >= ACE_COMPUTE_BASED_POINTER (&rhs); -} - -template ACE_INLINE void -ACE_Based_Pointer_Basic::operator= (const ACE_Based_Pointer_Basic &rhs) -{ - ACE_TRACE ("ACE_Based_Pointer_Basic::operator="); - *this = rhs.addr (); -} - -template ACE_INLINE void -ACE_Based_Pointer::operator= (const ACE_Based_Pointer &rhs) -{ - ACE_TRACE ("ACE_Based_Pointer::operator="); - *this = rhs.addr (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Basic_Stats.cpp b/deps/acelite/ace/Basic_Stats.cpp deleted file mode 100644 index 98e3193f3..000000000 --- a/deps/acelite/ace/Basic_Stats.cpp +++ /dev/null @@ -1,74 +0,0 @@ -#include "ace/Basic_Stats.h" -#include "ace/Log_Category.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Basic_Stats.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -void -ACE_Basic_Stats::accumulate (const ACE_Basic_Stats &rhs) -{ - if (rhs.samples_count_ == 0) - return; - - if (this->samples_count_ == 0) - { - this->min_ = rhs.min_; - this->min_at_ = rhs.min_at_; - - this->max_ = rhs.max_; - this->max_at_ = rhs.max_at_; - } - else - { - if (this->min_ > rhs.min_) - { - this->min_ = rhs.min_; - this->min_at_ = rhs.min_at_; - } - if (this->max_ < rhs.max_) - { - this->max_ = rhs.max_; - this->max_at_ = rhs.max_at_; - } - } - - this->samples_count_ += rhs.samples_count_; - this->sum_ += rhs.sum_; -} - -void -ACE_Basic_Stats::dump_results ( - const ACE_TCHAR *msg, - ACE_Basic_Stats::scale_factor_type sf) const -{ -#ifndef ACE_NLOGGING - if (this->samples_count () == 0u) - { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("%s : no data collected\n"), msg)); - return; - } - - ACE_UINT64 avg = this->sum_ / this->samples_count_; - - ACE_UINT64 l_min = this->min_ / sf; - ACE_UINT64 l_max = this->max_ / sf; - ACE_UINT64 l_avg = avg / sf; - - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("%s latency : %Q[%d]/%Q/%Q[%d] (min/avg/max)\n"), - msg, - l_min, this->min_at_, - l_avg, - l_max, this->max_at_)); - -#else - ACE_UNUSED_ARG (msg); - ACE_UNUSED_ARG (sf); -#endif /* ACE_NLOGGING */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Basic_Stats.h b/deps/acelite/ace/Basic_Stats.h deleted file mode 100644 index 4cc4bd2d6..000000000 --- a/deps/acelite/ace/Basic_Stats.h +++ /dev/null @@ -1,90 +0,0 @@ - -//============================================================================= -/** - * @file Basic_Stats.h - * - * @author Carlos O'Ryan - */ -//============================================================================= - -#ifndef ACE_BASIC_STATS_H -#define ACE_BASIC_STATS_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" -#include "ace/Basic_Types.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/// Collect basic stats about a series of samples -/** - * Compute the average and standard deviation (aka jitter) for an - * arbitrary number of samples, using constant space. - * Normally used for latency statistics. - */ -class ACE_Export ACE_Basic_Stats -{ -public: -#if !defined (ACE_WIN32) - typedef ACE_UINT32 scale_factor_type; -#else - typedef ACE_UINT64 scale_factor_type; -#endif - - /// Constructor - /** - * The number of samples is pre-allocated, and cannot changes once - * the class is initialized. - */ - ACE_Basic_Stats (void); - - /// The number of samples received so far - ACE_UINT32 samples_count (void) const; - - /// Record one sample. - void sample (ACE_UINT64 value); - - /// Update the values to reflect the stats in @a rhs. - void accumulate (const ACE_Basic_Stats &rhs); - - /// Dump all the samples - /** - * Prints out the results, using @a msg as a prefix for each message and - * scaling all the numbers by @a scale_factor. The latter is useful because - * high resolution timer samples are acquired in clock ticks, but often - * presented in microseconds. - */ - void dump_results (const ACE_TCHAR *msg, - scale_factor_type scale_factor) const; - - /// The number of samples - ACE_UINT32 samples_count_; - - /// The minimum value - ACE_UINT64 min_; - - /// The number of the sample that had the minimum value - ACE_UINT32 min_at_; - - /// The maximum value - ACE_UINT64 max_; - - /// The number of the sample that had the maximum value - ACE_UINT32 max_at_; - - /// The sum of all the values - ACE_UINT64 sum_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Basic_Stats.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_BASIC_STATS_H */ diff --git a/deps/acelite/ace/Basic_Stats.inl b/deps/acelite/ace/Basic_Stats.inl deleted file mode 100644 index 185478ab7..000000000 --- a/deps/acelite/ace/Basic_Stats.inl +++ /dev/null @@ -1,50 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Basic_Stats::ACE_Basic_Stats (void) - : samples_count_ (0) - , min_ (0) - , min_at_ (0) - , max_ (0) - , max_at_ (0) - , sum_ (0) -{ -} - -ACE_INLINE ACE_UINT32 -ACE_Basic_Stats::samples_count (void) const -{ - return this->samples_count_; -} - -ACE_INLINE void -ACE_Basic_Stats::sample (ACE_UINT64 value) -{ - ++this->samples_count_; - - if (this->samples_count_ == 1u) - { - this->min_ = value; - this->min_at_ = this->samples_count_; - this->max_ = value; - this->max_at_ = this->samples_count_; - } - else - { - if (this->min_ > value) - { - this->min_ = value; - this->min_at_ = this->samples_count_; - } - if (this->max_ < value) - { - this->max_ = value; - this->max_at_ = this->samples_count_; - } - } - - this->sum_ += value; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Basic_Types.cpp b/deps/acelite/ace/Basic_Types.cpp deleted file mode 100644 index 56867684e..000000000 --- a/deps/acelite/ace/Basic_Types.cpp +++ /dev/null @@ -1 +0,0 @@ -#include "ace/Basic_Types.h" diff --git a/deps/acelite/ace/Basic_Types.h b/deps/acelite/ace/Basic_Types.h deleted file mode 100644 index 67916f8dc..000000000 --- a/deps/acelite/ace/Basic_Types.h +++ /dev/null @@ -1,690 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Basic_Types.h - * - * @author David L. Levine - * - * #defines the list of preprocessor macros below. The config.h file can - * pre-define any of these to short-cut the definitions. This is usually - * only necessary if the preprocessor does all of its math using integers. - * - * Sizes of built-in types: - * - ACE_SIZEOF_CHAR - * - ACE_SIZEOF_WCHAR - * - ACE_SIZEOF_SHORT - * - ACE_SIZEOF_INT - * - ACE_SIZEOF_LONG - * - ACE_SIZEOF_LONG_LONG - * - ACE_SIZEOF_VOID_P - * - ACE_SIZEOF_FLOAT - * - ACE_SIZEOF_DOUBLE - * - ACE_SIZEOF_LONG_DOUBLE - * - * Wrappers for built-in types of specific sizes: - * - ACE_INT8 - * - ACE_UINT8 - * - ACE_INT16 - * - ACE_UINT16 - * - ACE_INT32 - * - ACE_UINT32 - * - ACE_INT64 - * - ACE_UINT64 - * - * Byte-order (endian-ness) determination: - * ACE_BYTE_ORDER, to either ACE_BIG_ENDIAN or ACE_LITTLE_ENDIAN - */ -//============================================================================= - -#include /**/ "ace/config-lite.h" - -#ifndef ACE_BASIC_TYPES_H -# define ACE_BASIC_TYPES_H - -# include /**/ "ace/pre.h" - -# if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -# endif /* ACE_LACKS_PRAGMA_ONCE */ - -// Pull in definitions -# include "ace/os_include/os_limits.h" // Integer limits -# include "ace/os_include/os_float.h" // Floating point limits -# include "ace/os_include/os_stdlib.h" // Other types -# include "ace/os_include/os_stddef.h" // Get ptrdiff_t - see further comments below -# include "ace/os_include/arpa/os_inet.h" // For htons - -# include "ace/os_include/sys/os_types.h" - -# if !defined (ACE_LACKS_SYS_PARAM_H) -# include /**/ -# endif /* ACE_LACKS_SYS_PARAM_H */ - -# include "ace/ACE_export.h" - -# if !defined (ACE_LACKS_STDINT_H) -# include -# endif -# if !defined (ACE_LACKS_INTTYPES_H) -# include -# endif - -# if defined (ACE_HAS_CPP11) -# define ACE_HAS_INT8_T -# define ACE_HAS_UINT8_T -# define ACE_HAS_INT16_T -# define ACE_HAS_UINT16_T -# define ACE_HAS_INT32_T -# define ACE_HAS_UINT32_T -# define ACE_HAS_INT64_T -# define ACE_HAS_UINT64_T -# endif /* ACE_HAS_CPP11 */ - -#ifdef ACE_LACKS_INTPTR_T -# include "ace/If_Then_Else.h" - -// This intptr_t typedef is here instead of -// since it depends on the template -// metaprogramming in . - -// We could compare ACE_SIZEOF_VOID_P against ACE_SIZEOF_LONG, etc. -// However, that depends on the ACE preprocessor symbol definitions in -// the platform-specific configuration header being correct. -// The template meta-programming approach we take below, -// i.e. determining the type at compile-time rather than at -// preprocessing-time, will work for all platforms, and does not -// depend on ACE developer-defined configuration parameters. - -typedef ACE::If_Then_Else< - (sizeof (void*) == sizeof (signed int)), - signed int, - ACE::If_Then_Else< - (sizeof (void*) == sizeof (signed long)), - signed long, - ACE::If_Then_Else< - (sizeof (void*) == sizeof (signed long long)), - signed long long, - void /* Unknown. Force an invalid type */ - >::result_type - >::result_type - >::result_type intptr_t; - -typedef ACE::If_Then_Else< - (sizeof (void*) == sizeof (unsigned int)), - unsigned int, - ACE::If_Then_Else< - (sizeof (void*) == sizeof (unsigned long)), - unsigned long, - ACE::If_Then_Else< - (sizeof (void*) == sizeof (unsigned long long)), - unsigned long long, - void /* Unknown. Force an invalid type */ - >::result_type - >::result_type - >::result_type uintptr_t; - -#endif /* ACE_LACKS_INTPTR_T */ - -// A char always has 1 byte, by definition. -# define ACE_SIZEOF_CHAR 1 - -// Unfortunately, there isn't a portable way to determine the size of a wchar. -// So we just define them on a platform basis. If the platform doesn't -// define it and it's an XPG4 system, assume wchar_t is 4 bytes. Some code -// uses ACE_SIZEOF_WCHAR in preprocessor statements, so sizeof() isn't valid. -// If the platform config doesn't set this, and this guess is wrong, -// Basic_Types_Test should catch the inconsistency. -# if defined (ACE_HAS_WCHAR) -# if !defined (ACE_SIZEOF_WCHAR) -# if defined (ACE_HAS_XPG4_MULTIBYTE_CHAR) -# define ACE_SIZEOF_WCHAR 4 -# else -// 0 so the Basic_Types test will catch this. -# define ACE_SIZEOF_WCHAR 0 -# endif /* ACE_HAS_XPG4_MULTIBYTE_CHAR */ -# endif /* !ACE_SIZEOF_WCHAR */ -# endif /* ACE_HAS_WCHAR */ - -// The number of bytes in a short. -# if !defined (ACE_SIZEOF_SHORT) -# if (USHRT_MAX) == 255U -# define ACE_SIZEOF_SHORT 1 -# elif (USHRT_MAX) == 65535U -# define ACE_SIZEOF_SHORT 2 -# elif (USHRT_MAX) == 4294967295U -# define ACE_SIZEOF_SHORT 4 -# elif (USHRT_MAX) == 18446744073709551615U -# define ACE_SIZEOF_SHORT 8 -# else -# error: unsupported short size, must be updated for this platform! -# endif /* USHRT_MAX */ -# endif /* !defined (ACE_SIZEOF_SHORT) */ - -// The number of bytes in an int. -# if !defined (ACE_SIZEOF_INT) -# if (UINT_MAX) == 65535U -# define ACE_SIZEOF_INT 2 -# elif (UINT_MAX) == 4294967295U -# define ACE_SIZEOF_INT 4 -# elif (UINT_MAX) == 18446744073709551615U -# define ACE_SIZEOF_INT 8 -# else -# error: unsupported int size, must be updated for this platform! -# endif /* UINT_MAX */ -# endif /* !defined (ACE_SIZEOF_INT) */ - -// The number of bytes in a long. -# if !defined (ACE_SIZEOF_LONG) -# if (ULONG_MAX) == 65535UL -# define ACE_SIZEOF_LONG 2 -# elif ((ULONG_MAX) == 4294967295UL) -# define ACE_SIZEOF_LONG 4 -# elif ((ULONG_MAX) == 18446744073709551615UL) -# define ACE_SIZEOF_LONG 8 -# else -# error: unsupported long size, must be updated for this platform! -# endif /* ULONG_MAX */ -# endif /* !defined (ACE_SIZEOF_LONG) */ - -// The number of bytes in a long long. -# if !defined (ACE_SIZEOF_LONG_LONG) -# if defined (ULLONG_MAX) -# if ((ULLONG_MAX) == 4294967295ULL) -# define ACE_SIZEOF_LONG_LONG 4 -# elif ((ULLONG_MAX) == 18446744073709551615ULL) -# define ACE_SIZEOF_LONG_LONG 8 -# endif -# elif defined (ULONGLONG_MAX) -# if ((ULONGLONG_MAX) == 4294967295ULL) -# define ACE_SIZEOF_LONG_LONG 4 -# elif ((ULONGLONG_MAX) == 18446744073709551615ULL) -# define ACE_SIZEOF_LONG_LONG 8 -# endif -# endif -# // If we can't determine the size of long long, assume it is 8 -# // instead of erroring out. (Either ULLONG_MAX and ULONGLONG_MAX -# // may not be supported; or an extended C/C++ dialect may need to -# // be selected. If this assumption is wrong, it can be addressed -# // in the platform-specific config header. -# if !defined (ACE_SIZEOF_LONG_LONG) -# define ACE_SIZEOF_LONG_LONG 8 -# endif -# endif /* !defined (ACE_SIZEOF_LONG_LONG) */ - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// The sizes of the commonly implemented types are now known. Set up -// typedefs for whatever we can. Some of these are needed for certain -// cases of ACE_UINT64, so do them before the 64-bit stuff. - -#if defined (ACE_HAS_INT8_T) - typedef int8_t ACE_INT8; -#elif defined (ACE_INT8_TYPE) - typedef ACE_INT8_TYPE ACE_INT8; -#elif !defined (ACE_LACKS_SIGNED_CHAR) - typedef signed char ACE_INT8; -#else - typedef char ACE_INT8; -#endif /* defined (ACE_INT8_TYPE) */ - -#if defined (ACE_HAS_UINT8_T) - typedef uint8_t ACE_UINT8; -#elif defined (ACE_UINT8_TYPE) - typedef ACE_UINT8_TYPE ACE_UINT8; -#else - typedef unsigned char ACE_UINT8; -#endif /* defined (ACE_UINT8_TYPE) */ - -#if defined (ACE_HAS_INT16_T) - typedef int16_t ACE_INT16; -#elif defined (ACE_INT16_TYPE) - typedef ACE_INT16_TYPE ACE_INT16; -#elif ACE_SIZEOF_SHORT == 2 - typedef short ACE_INT16; -#elif ACE_SIZEOF_INT == 2 - typedef int ACE_INT16; -#else -# error Have to add to the ACE_INT16 type setting -#endif /* defined (ACE_INT16_TYPE) */ - -#if defined (ACE_HAS_UINT16_T) - typedef uint16_t ACE_UINT16; -#elif defined (ACE_UINT16_TYPE) - typedef ACE_UINT16_TYPE ACE_UINT16; -#elif ACE_SIZEOF_SHORT == 2 - typedef unsigned short ACE_UINT16; -#elif ACE_SIZEOF_INT == 2 - typedef unsigned int ACE_UINT16; -#else -# error Have to add to the ACE_UINT16 type setting -#endif /* defined (ACE_UINT16_TYPE) */ - -#if defined (ACE_HAS_INT32_T) - typedef int32_t ACE_INT32; -#elif defined (ACE_INT32_TYPE) - typedef ACE_INT32_TYPE ACE_INT32; -#elif ACE_SIZEOF_INT == 4 - typedef int ACE_INT32; -#elif ACE_SIZEOF_LONG == 4 - typedef long ACE_INT32; -#else -# error Have to add to the ACE_INT32 type setting -#endif /* defined (ACE_INT32_TYPE) */ - -#if defined (ACE_HAS_UINT32_T) - typedef uint32_t ACE_UINT32; -#elif defined (ACE_UINT32_TYPE) - typedef ACE_UINT32_TYPE ACE_UINT32; -#elif ACE_SIZEOF_INT == 4 - typedef unsigned int ACE_UINT32; -#elif ACE_SIZEOF_LONG == 4 - typedef unsigned long ACE_UINT32; -#else -# error Have to add to the ACE_UINT32 type setting -#endif /* defined (ACE_UINT32_TYPE) */ - -#if defined (ACE_HAS_INT64_T) - typedef int64_t ACE_INT64; -#elif defined (ACE_INT64_TYPE) - typedef ACE_INT64_TYPE ACE_INT64; -#elif ACE_SIZEOF_LONG == 8 - typedef long ACE_INT64; -#elif ACE_SIZEOF_LONG_LONG == 8 -# ifdef __GNUC__ - // Silence g++ "-pedantic" warnings regarding use of "long long" - // type. - __extension__ -# endif /* __GNUC__ */ - typedef long long ACE_INT64; -#endif /* defined (ACE_INT64_TYPE) */ - -#if defined (ACE_HAS_UINT64_T) - typedef uint64_t ACE_UINT64; -#elif defined (ACE_UINT64_TYPE) - typedef ACE_UINT64_TYPE ACE_UINT64; -#elif ACE_SIZEOF_LONG == 8 - typedef unsigned long ACE_UINT64; -#elif ACE_SIZEOF_LONG_LONG == 8 -# ifdef __GNUC__ - // Silence g++ "-pedantic" warnings regarding use of "long long" - // type. - __extension__ -# endif /* __GNUC__ */ - typedef unsigned long long ACE_UINT64; -#endif /* defined (ACE_UINT64_TYPE) */ - -/// Define a generic byte for use in codecs -typedef unsigned char ACE_Byte; - -// Define a pseudo wide character type when wchar is not supported so we -// can support basic wide character string operations. - -#if defined (ACE_HAS_WCHAR) || defined (ACE_HAS_XPG4_MULTIBYTE_CHAR) -# define ACE_WINT_T wint_t -# define ACE_WCHAR_T wchar_t -#else -# define ACE_WINT_T ACE_UINT16 -# define ACE_WCHAR_T ACE_UINT16 -#endif /* ACE_HAS_WCHAR */ - -// The number of bytes in a void *. -#ifndef ACE_SIZEOF_VOID_P -# define ACE_SIZEOF_VOID_P ACE_SIZEOF_LONG -#endif /* ACE_SIZEOF_VOID_P */ - -ACE_END_VERSIONED_NAMESPACE_DECL - -// Byte-order (endian-ness) determination. -#if defined (BYTE_ORDER) -# if (BYTE_ORDER == LITTLE_ENDIAN) -# define ACE_LITTLE_ENDIAN 0x0123 -# define ACE_BYTE_ORDER ACE_LITTLE_ENDIAN -# elif (BYTE_ORDER == BIG_ENDIAN) -# define ACE_BIG_ENDIAN 0x3210 -# define ACE_BYTE_ORDER ACE_BIG_ENDIAN -# else -# error: unknown BYTE_ORDER! -# endif /* BYTE_ORDER */ -#elif defined (_BYTE_ORDER) -# if (_BYTE_ORDER == _LITTLE_ENDIAN) -# define ACE_LITTLE_ENDIAN 0x0123 -# define ACE_BYTE_ORDER ACE_LITTLE_ENDIAN -# elif (_BYTE_ORDER == _BIG_ENDIAN) -# define ACE_BIG_ENDIAN 0x3210 -# define ACE_BYTE_ORDER ACE_BIG_ENDIAN -# else -# error: unknown _BYTE_ORDER! -# endif /* _BYTE_ORDER */ -#elif defined (__BYTE_ORDER) -# if (__BYTE_ORDER == __LITTLE_ENDIAN) -# define ACE_LITTLE_ENDIAN 0x0123 -# define ACE_BYTE_ORDER ACE_LITTLE_ENDIAN -# elif (__BYTE_ORDER == __BIG_ENDIAN) -# define ACE_BIG_ENDIAN 0x3210 -# define ACE_BYTE_ORDER ACE_BIG_ENDIAN -# else -# error: unknown __BYTE_ORDER! -# endif /* __BYTE_ORDER */ -#else /* ! BYTE_ORDER && ! __BYTE_ORDER */ - // We weren't explicitly told, so we have to figure it out . . . - // Note that Itanium hardware (IA64) can run in either byte order. It's - // selected by the OS when loading; Windows runs little, HP-UX runs big. -# if defined (i386) || defined (__i386__) || defined (_M_IX86) || \ - defined (vax) || defined (__alpha) || defined (__LITTLE_ENDIAN__) || \ - defined (ARM) || defined (_M_IA64) || defined (_M_AMD64) || \ - defined (__amd64) || \ - ((defined (__ia64__) || defined (__ia64)) && !defined (__hpux)) - // We know these are little endian. -# define ACE_LITTLE_ENDIAN 0x0123 -# define ACE_BYTE_ORDER ACE_LITTLE_ENDIAN -# else - // Otherwise, we assume big endian. -# define ACE_BIG_ENDIAN 0x3210 -# define ACE_BYTE_ORDER ACE_BIG_ENDIAN -# endif -#endif /* ! BYTE_ORDER && ! __BYTE_ORDER */ - -// Byte swapping macros to deal with differences between little endian -// and big endian machines. Note that "long" here refers to 32 bit -// quantities. -# define ACE_SWAP_LONG(L) ((ACE_SWAP_WORD ((L) & 0xFFFF) << 16) \ - | ACE_SWAP_WORD(((L) >> 16) & 0xFFFF)) -# define ACE_SWAP_WORD(L) ((((L) & 0x00FF) << 8) | (((L) & 0xFF00) >> 8)) - -# define ACE_HTONL(X) htonl (X) -# define ACE_NTOHL(X) ntohl (X) - -# if defined (ACE_LITTLE_ENDIAN) -# define ACE_IDL_NCTOHL(X) (X) -# define ACE_IDL_NSTOHL(X) (X) -# else -# define ACE_IDL_NCTOHL(X) (X << 24) -# define ACE_IDL_NSTOHL(X) ((X) << 16) -# endif /* ACE_LITTLE_ENDIAN */ - -// MQX doesn't define these macros correctly. -# if defined (ACE_LITTLE_ENDIAN) && defined (ACE_MQX) -# define ACE_HTONS(x) x -# define ACE_NTOHS(x) x -# else -# define ACE_HTONS(x) htons(x) -# define ACE_NTOHS(x) ntohs(x) -# endif - -# define ACE_LONGLONG_TO_PTR(PTR_TYPE, L) \ - reinterpret_cast (static_cast (L)) - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -inline ACE_UINT32 -ACE_U64_TO_U32 (ACE_UINT64 n) -{ - return static_cast (n); -} - -inline ACE_UINT32 -ACE_CU64_TO_CU32 (ACE_UINT64 n) -{ - return static_cast (n); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_WIN32) -# if defined (__MINGW32__) -# define ACE_UINT64_LITERAL(n) n ## ull -# define ACE_INT64_LITERAL(n) n ## ll -# else -# define ACE_UINT64_LITERAL(n) n ## ui64 -# define ACE_INT64_LITERAL(n) n ## i64 -# endif /* defined (__MINGW32__) */ -#else /* ! ACE_WIN32 */ -# define ACE_UINT64_LITERAL(n) n ## ull -# define ACE_INT64_LITERAL(n) n ## ll -#endif /* ! ACE_WIN32*/ - -#if !defined (ACE_INT8_FORMAT_SPECIFIER_ASCII) -# if defined (PRId8) -# define ACE_INT8_FORMAT_SPECIFIER_ASCII "%" PRId8 -# else -# define ACE_INT8_FORMAT_SPECIFIER_ASCII "%d" -# endif /* defined (PRId8) */ -#endif /* ACE_INT8_FORMAT_SPECIFIER_ASCII */ - -#if !defined (ACE_INT8_FORMAT_SPECIFIER) -# if defined (PRId8) -# define ACE_INT8_FORMAT_SPECIFIER ACE_TEXT ("%") ACE_TEXT (PRId8) -# else -# define ACE_INT8_FORMAT_SPECIFIER ACE_TEXT (ACE_INT8_FORMAT_SPECIFIER_ASCII) -# endif /* defined (PRId8) */ -#endif /* ACE_INT8_FORMAT_SPECIFIER */ - -#if !defined (ACE_UINT8_FORMAT_SPECIFIER_ASCII) -# if defined (PRIu8) -# define ACE_UINT8_FORMAT_SPECIFIER_ASCII "%" PRIu8 -# else -# define ACE_UINT8_FORMAT_SPECIFIER_ASCII "%u" -# endif /* defined (PRIu8) */ -#endif /* ACE_UINT8_FORMAT_SPECIFIER */ - -#if !defined (ACE_UINT8_FORMAT_SPECIFIER) -# if defined (PRIu8) -# define ACE_UINT8_FORMAT_SPECIFIER ACE_TEXT ("%") ACE_TEXT (PRIu8) -# else -# define ACE_UINT8_FORMAT_SPECIFIER ACE_TEXT (ACE_UINT8_FORMAT_SPECIFIER_ASCII) -# endif /* defined (PRIu8) */ -#endif /* ACE_UINT8_FORMAT_SPECIFIER */ - -#if !defined (ACE_INT16_FORMAT_SPECIFIER_ASCII) -# if defined (PRId16) -# define ACE_INT16_FORMAT_SPECIFIER_ASCII "%" PRId16 -# else -# define ACE_INT16_FORMAT_SPECIFIER_ASCII "%d" -# endif /* defined (PRId16) */ -#endif /* ACE_INT16_FORMAT_SPECIFIER */ - -#if !defined (ACE_INT16_FORMAT_SPECIFIER) -# if defined (PRId16) -# define ACE_INT16_FORMAT_SPECIFIER ACE_TEXT ("%") ACE_TEXT (PRId16) -# else -# define ACE_INT16_FORMAT_SPECIFIER ACE_TEXT (ACE_INT16_FORMAT_SPECIFIER_ASCII) -# endif /* defined (PRId16) */ -#endif /* ACE_INT16_FORMAT_SPECIFIER */ - -#if !defined (ACE_UINT16_FORMAT_SPECIFIER_ASCII) -# if defined (PRIu16) -# define ACE_UINT16_FORMAT_SPECIFIER_ASCII "%" PRIu16 -# else -# define ACE_UINT16_FORMAT_SPECIFIER_ASCII "%u" -# endif /* defined (PRIu16) */ -#endif /* ACE_UINT16_FORMAT_SPECIFIER */ - -#if !defined (ACE_UINT16_FORMAT_SPECIFIER) -# if defined (PRIu16) -# define ACE_UINT16_FORMAT_SPECIFIER ACE_TEXT ("%") ACE_TEXT (PRIu16) -# else -# define ACE_UINT16_FORMAT_SPECIFIER ACE_TEXT (ACE_UINT16_FORMAT_SPECIFIER_ASCII) -# endif /* defined (PRIu16) */ -#endif /* ACE_UINT16_FORMAT_SPECIFIER */ - -#if !defined (ACE_INT32_FORMAT_SPECIFIER_ASCII) -# if defined (PRId32) -# define ACE_INT32_FORMAT_SPECIFIER_ASCII "%" PRId32 -# elif ACE_SIZEOF_INT == 4 -# define ACE_INT32_FORMAT_SPECIFIER_ASCII "%d" -# else -# define ACE_INT32_FORMAT_SPECIFIER_ASCII "%ld" -# endif /* defined (PRId32) */ -#endif /* ACE_INT32_FORMAT_SPECIFIER */ - -#if !defined (ACE_INT32_FORMAT_SPECIFIER) -# if defined (PRId32) -# define ACE_INT32_FORMAT_SPECIFIER ACE_TEXT ("%") ACE_TEXT (PRId32) -# else -# define ACE_INT32_FORMAT_SPECIFIER ACE_TEXT (ACE_INT32_FORMAT_SPECIFIER_ASCII) -# endif /* defined (PRId32) */ -#endif /* ACE_INT32_FORMAT_SPECIFIER */ - -#if !defined (ACE_UINT32_FORMAT_SPECIFIER_ASCII) -# if defined (PRIu32) -# define ACE_UINT32_FORMAT_SPECIFIER_ASCII "%" PRIu32 -# elif ACE_SIZEOF_INT == 4 -# define ACE_UINT32_FORMAT_SPECIFIER_ASCII "%u" -# else -# define ACE_UINT32_FORMAT_SPECIFIER_ASCII "%lu" -# endif /* defined (PRIu32) */ -#endif /* ACE_UINT32_FORMAT_SPECIFIER */ - -#if !defined (ACE_UINT32_FORMAT_SPECIFIER) -# if defined (PRIu32) -# define ACE_UINT32_FORMAT_SPECIFIER ACE_TEXT ("%") ACE_TEXT (PRIu32) -# else -# define ACE_UINT32_FORMAT_SPECIFIER ACE_TEXT (ACE_UINT32_FORMAT_SPECIFIER_ASCII) -# endif /* defined (PRIu32) */ -#endif /* ACE_UINT32_FORMAT_SPECIFIER */ - -#if !defined (ACE_INT64_FORMAT_SPECIFIER_ASCII) -# if defined (PRId64) -# define ACE_INT64_FORMAT_SPECIFIER_ASCII "%" PRId64 -# elif ACE_SIZEOF_LONG == 8 -# define ACE_INT64_FORMAT_SPECIFIER_ASCII "%ld" -# else -# define ACE_INT64_FORMAT_SPECIFIER_ASCII "%lld" -# endif /* defined (PRId64) */ -#endif /* ACE_INT64_FORMAT_SPECIFIER */ - -#if !defined (ACE_INT64_FORMAT_SPECIFIER) -# if defined (PRId64) -# define ACE_INT64_FORMAT_SPECIFIER ACE_TEXT ("%") ACE_TEXT (PRId64) -# else -# define ACE_INT64_FORMAT_SPECIFIER ACE_TEXT (ACE_INT64_FORMAT_SPECIFIER_ASCII) -# endif /* defined (PRId64) */ -#endif /* ACE_INT64_FORMAT_SPECIFIER */ - -#if !defined (ACE_UINT64_FORMAT_SPECIFIER_ASCII) -# if defined (PRIu64) -# define ACE_UINT64_FORMAT_SPECIFIER_ASCII "%" PRIu64 -# elif ACE_SIZEOF_LONG == 8 -# define ACE_UINT64_FORMAT_SPECIFIER_ASCII "%lu" -# else -# define ACE_UINT64_FORMAT_SPECIFIER_ASCII "%llu" -# endif /* defined (PRIu64) */ -#endif /* ACE_UINT64_FORMAT_SPECIFIER_ASCII */ - -#if !defined (ACE_UINT64_FORMAT_SPECIFIER) -# if defined (PRIu64) -# define ACE_UINT64_FORMAT_SPECIFIER ACE_TEXT ("%") ACE_TEXT (PRIu64) -# else -# define ACE_UINT64_FORMAT_SPECIFIER ACE_TEXT (ACE_UINT64_FORMAT_SPECIFIER_ASCII) -# endif /* defined (PRIu64) */ -#endif /* ACE_UINT64_FORMAT_SPECIFIER */ - -#if !defined (ACE_SSIZE_T_FORMAT_SPECIFIER_ASCII) -# if defined (ACE_WIN64) -# define ACE_SSIZE_T_FORMAT_SPECIFIER_ASCII "%I64d" -# elif defined (_WRS_CONFIG_LP64) -# define ACE_SSIZE_T_FORMAT_SPECIFIER_ASCII "%ld" -# else -# define ACE_SSIZE_T_FORMAT_SPECIFIER_ASCII "%d" -# endif /* ACE_WIN64 */ -#endif /* ACE_SSIZE_T_FORMAT_SPECIFIER */ - -#if !defined (ACE_SSIZE_T_FORMAT_SPECIFIER) -#define ACE_SSIZE_T_FORMAT_SPECIFIER ACE_TEXT (ACE_SSIZE_T_FORMAT_SPECIFIER_ASCII) -#endif /* ACE_SSIZE_T_FORMAT_SPECIFIER */ - -#if !defined (ACE_SIZE_T_FORMAT_SPECIFIER_ASCII) -# if defined (ACE_WIN64) -# define ACE_SIZE_T_FORMAT_SPECIFIER_ASCII "%I64u" -# elif defined (_WRS_CONFIG_LP64) -# define ACE_SIZE_T_FORMAT_SPECIFIER_ASCII "%lu" -# else -# define ACE_SIZE_T_FORMAT_SPECIFIER_ASCII "%u" -# endif /* ACE_WIN64 */ -#endif /* ACE_SIZE_T_FORMAT_SPECIFIER */ - -#if !defined (ACE_SIZE_T_FORMAT_SPECIFIER) -#define ACE_SIZE_T_FORMAT_SPECIFIER ACE_TEXT (ACE_SIZE_T_FORMAT_SPECIFIER_ASCII) -#endif /* ACE_SIZE_T_FORMAT_SPECIFIER */ - -// Cast from UINT64 to a double requires an intermediate cast to INT64 -// on some platforms. -#if defined (ACE_WIN32) -# define ACE_UINT64_DBLCAST_ADAPTER(n) static_cast<__int64> (n) -#else /* ! ACE_WIN32 && */ -# define ACE_UINT64_DBLCAST_ADAPTER(n) (n) -#endif /* ! ACE_WIN32 && */ - - -// The number of bytes in a float. -# ifndef ACE_SIZEOF_FLOAT -# if FLT_MAX_EXP == 128 -# define ACE_SIZEOF_FLOAT 4 -# elif FLT_MAX_EXP == 1024 -# define ACE_SIZEOF_FLOAT 8 -# else -# error: unsupported float size, must be updated for this platform! -# endif /* FLT_MAX_EXP */ -# endif /* ACE_SIZEOF_FLOAT */ - -// The number of bytes in a double. -# ifndef ACE_SIZEOF_DOUBLE -# if DBL_MAX_EXP == 128 -# define ACE_SIZEOF_DOUBLE 4 -# elif DBL_MAX_EXP == 1024 -# define ACE_SIZEOF_DOUBLE 8 -# else -# error: unsupported double size, must be updated for this platform! -# endif /* DBL_MAX_EXP */ -# endif /* ACE_SIZEOF_DOUBLE */ - -// The number of bytes in a long double. -# ifndef ACE_SIZEOF_LONG_DOUBLE -# if LDBL_MAX_EXP == 128 -# define ACE_SIZEOF_LONG_DOUBLE 4 -# elif LDBL_MAX_EXP == 1024 -# if defined (__powerpc64__) -# define ACE_SIZEOF_LONG_DOUBLE 16 -# else -# define ACE_SIZEOF_LONG_DOUBLE 8 -# endif -# elif LDBL_MAX_EXP == 16384 -# if defined (LDBL_DIG) && LDBL_DIG == 18 -# if defined (__ia64) || defined (__x86_64) -# define ACE_SIZEOF_LONG_DOUBLE 16 -# else /* ! __ia64 || __x86_64 */ -# define ACE_SIZEOF_LONG_DOUBLE 12 -# endif /* __ia64 */ -# else /* ! LDBL_DIG || LDBL_DIG != 18 */ -# define ACE_SIZEOF_LONG_DOUBLE 16 -# endif /* ! LDBL_DIG || LDBL_DIG != 18 */ -# else -# error: unsupported double size, must be updated for this platform! -# endif /* LDBL_MAX_EXP */ -# endif /* ACE_SIZEOF_LONG_DOUBLE */ - -// Max and min sizes for the ACE integer types. -#define ACE_CHAR_MAX 0x7F -#define ACE_CHAR_MIN -(ACE_CHAR_MAX)-1 -#define ACE_OCTET_MAX 0xFF -#define ACE_INT16_MAX 0x7FFF -#define ACE_INT16_MIN -(ACE_INT16_MAX)-1 -#define ACE_UINT16_MAX 0xFFFF -#define ACE_WCHAR_MAX ACE_UINT16_MAX -#define ACE_INT32_MAX 0x7FFFFFFF -#define ACE_INT32_MIN -(ACE_INT32_MAX)-1 -#define ACE_UINT32_MAX 0xFFFFFFFF -#define ACE_INT64_MAX ACE_INT64_LITERAL(0x7FFFFFFFFFFFFFFF) -#define ACE_INT64_MIN -(ACE_INT64_MAX)-1 -#define ACE_UINT64_MAX ACE_UINT64_LITERAL (0xFFFFFFFFFFFFFFFF) - -// These use ANSI/IEEE format. -#define ACE_FLT_MAX 3.402823466e+38F -#define ACE_FLT_MIN 1.175494351e-38F -#define ACE_DBL_MAX 1.7976931348623158e+308 -#define ACE_DBL_MIN 2.2250738585072014e-308 - -# include /**/ "ace/post.h" -#endif /* ACE_BASIC_TYPES_H */ diff --git a/deps/acelite/ace/Bound_Ptr.cpp b/deps/acelite/ace/Bound_Ptr.cpp deleted file mode 100644 index 930fe6bd4..000000000 --- a/deps/acelite/ace/Bound_Ptr.cpp +++ /dev/null @@ -1,17 +0,0 @@ -/* -*- C++ -*- */ -#ifndef ACE_BOUND_PTR_CPP -#define ACE_BOUND_PTR_CPP - -#include "ace/Bound_Ptr.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Bound_Ptr.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Bound_Ptr_Counter) - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_BOUND_PTR_CPP */ diff --git a/deps/acelite/ace/Bound_Ptr.h b/deps/acelite/ace/Bound_Ptr.h deleted file mode 100644 index 6626b97b3..000000000 --- a/deps/acelite/ace/Bound_Ptr.h +++ /dev/null @@ -1,400 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Bound_Ptr.h - * - * @author Christopher Kohlhoff - * @author Boris Kolpackov - */ -//============================================================================= - -#ifndef ACE_BOUND_PTR_H -#define ACE_BOUND_PTR_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (ACE_HAS_CPP11) -# include "ace/Auto_Ptr.h" -#endif /* !ACE_HAS_CPP11 */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Bound_Ptr_Counter - * - * @brief An ACE_Bound_Ptr_Counter object encapsulates an - * object reference count. - * - * Do not use this class directly, use ACE_Strong_Bound_Ptr or - * ACE_Weak_Bound_Ptr instead. - */ -template -class ACE_Bound_Ptr_Counter -{ -public: - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - ACE_Bound_Ptr_Counter (long init_obj_ref_count = 0); - ~ACE_Bound_Ptr_Counter (void); - - /// Create a ACE_Bound_Ptr_Counter and initialize the - /// reference count to indicate ownership by a strong pointer. - static ACE_Bound_Ptr_Counter *create_strong (void); - - /// Increase both the object and counter reference counts and return - /// the new object reference count. A return value of -1 indicates - /// that the object has already been destroyed. - static long attach_strong (ACE_Bound_Ptr_Counter *counter); - - /// Decreases both the object and counter reference counts and - /// deletes whichever has no more references. Returns the new object - /// reference count. - static long detach_strong (ACE_Bound_Ptr_Counter *counter); - - /// Create a ACE_Bound_Ptr_Counter and initialize the - /// reference count to indicate no ownership. - static ACE_Bound_Ptr_Counter *create_weak (void); - - /// Increase the counter reference count and return argument. - static void attach_weak (ACE_Bound_Ptr_Counter *counter); - - /// Decreases the counter reference count and deletes the counter if - /// it has no more references. - static void detach_weak (ACE_Bound_Ptr_Counter *counter); - - /// Determine whether the object has been deleted. - static bool object_was_deleted (ACE_Bound_Ptr_Counter *counter); - -private: - /// Allocate a new ACE_Bound_Ptr_Counter instance, - /// returning NULL if it cannot be created. - static ACE_Bound_Ptr_Counter *internal_create (long init_obj_ref_count); - -private: - /// Reference count of underlying object. Is set to -1 once the - /// object has been destroyed to indicate to all weak pointers that - /// it is no longer valid. - long obj_ref_count_; - - /// Reference count of this counter. - long self_ref_count_; - - /// Mutex variable to synchronize access to the reference counts. - ACE_LOCK lock_; -}; - -// Forward decl. -template class ACE_Weak_Bound_Ptr; - -/** - * @class ACE_Strong_Bound_Ptr - * - * @brief This class implements support for a reference counted - * pointer. - * - * Assigning or copying instances of an ACE_Strong_Bound_Ptr will - * automatically increment the reference count of the underlying object. - * When the last instance of an ACE_Strong_Bound_Ptr that references a - * particular object is destroyed or overwritten, it will invoke delete - * on its underlying pointer. - */ -template -class ACE_Strong_Bound_Ptr -{ -public: - /// Constructor that initializes an ACE_Strong_Bound_Ptr to point to the - /// object \ immediately. - explicit ACE_Strong_Bound_Ptr (X *p = 0); - -#if !defined (ACE_HAS_CPP11) - /// Constructor that initializes an ACE_Strong_Bound_Ptr by stealing - /// ownership of an object from an auto_ptr. - explicit ACE_Strong_Bound_Ptr (auto_ptr p); -#endif /* !ACE_HAS_CPP11 */ - - /// Copy constructor binds @c this and @a r to the same object. - ACE_Strong_Bound_Ptr (const ACE_Strong_Bound_Ptr &r); - - /// Constructor binds @c this and @a r to the same object. - ACE_Strong_Bound_Ptr (const ACE_Weak_Bound_Ptr &r); - - /// Copy constructor binds @c this and @a r to the same object if - /// Y* can be implicitly converted to X*. - template - ACE_Strong_Bound_Ptr (const ACE_Strong_Bound_Ptr &r) - : counter_ (r.counter_), - ptr_ (dynamic_cast(r.ptr_)) - { - // This ctor is temporarily defined here to increase our chances - // of being accepted by broken compilers. - // - COUNTER::attach_strong (this->counter_); - } - - /// Destructor. - ~ACE_Strong_Bound_Ptr (void); - - /// Assignment operator that binds @c this and @a r to the same object. - void operator = (const ACE_Strong_Bound_Ptr &r); - - /// Assignment operator that binds @c this and @a r to the same object. - void operator = (const ACE_Weak_Bound_Ptr &r); - - /// Assignment operator that binds @c this and @a r to the same object - /// if Y* can be implicitly converted to X*. - template - ACE_Weak_Bound_Ptr& - operator= (const ACE_Strong_Bound_Ptr &r) - { - // This operator is temporarily defined here to increase our chances - // of being accepted by broken compilers. - // - - // This will work if &r == this, by first increasing the ref count - - COUNTER *new_counter = r.counter_; - X* new_ptr = dynamic_cast (r.ptr_); - COUNTER::attach_strong (new_counter); - if (COUNTER::detach_strong (this->counter_) == 0) - delete this->ptr_; - this->counter_ = new_counter; - this->ptr_ = new_ptr; - - return *this; - } - - /// Equality operator that returns @c true if both - /// ACE_Strong_Bound_Ptr instances point to the same underlying - /// object. - /** - * @note It also returns @c true if both objects have just been - * instantiated and not used yet. - */ - bool operator == (const ACE_Strong_Bound_Ptr &r) const; - - /// Equality operator that returns true if the ACE_Strong_Bound_Ptr - /// and ACE_Weak_Bound_Ptr objects point to the same underlying - /// object. - /** - * @note It also returns @c true if both objects have just been - * instantiated and not used yet. - */ - bool operator == (const ACE_Weak_Bound_Ptr &r) const; - - /// Equality operator that returns @c true if the - /// ACE_Strong_Bound_Ptr and the raw pointer point to the same - /// underlying object. - bool operator == (X *p) const; - - /// Inequality operator, which is the opposite of equality. - bool operator != (const ACE_Strong_Bound_Ptr &r) const; - - /// Inequality operator, which is the opposite of equality. - bool operator != (const ACE_Weak_Bound_Ptr &r) const; - - /// Inequality operator, which is the opposite of equality. - bool operator != (X *p) const; - - /// Redirection operator - X *operator-> (void) const; - - /// Dereference operator - X &operator * (void) const; - - /// Get the pointer value. - X *get (void) const; - - /// Resets the ACE_Strong_Bound_Ptr to refer to a different - /// underlying object. - void reset (X *p = 0); - -#if !defined (ACE_HAS_CPP11) - /// Resets the ACE_Strong_Bound_Ptr to refer to a different - /// underlying object, ownership of which is stolen from the - /// auto_ptr. - void reset (auto_ptr p); -#endif /* !ACE_HAS_CPP11 */ - - /// Allows us to check for NULL on all ACE_Strong_Bound_Ptr - /// objects. - bool null (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - typedef X X_t; // This indirection is for Borland C++. - - friend class ACE_Weak_Bound_Ptr; - - template - friend class ACE_Strong_Bound_Ptr; - - /// The ACE_Bound_Ptr_Counter type. - typedef ACE_Bound_Ptr_Counter COUNTER; - - /// The reference counter. - COUNTER *counter_; - - /// The underlying object. - X *ptr_; -}; - -/** - * @class ACE_Weak_Bound_Ptr - * - * @brief This class implements support for a weak pointer that complements - * ACE_Strong_Bound_Ptr. - * - * Unlike ACE_Strong_Bound_Ptr, assigning or copying instances of an - * ACE_Weak_Bound_Ptr will not automatically increment the reference - * count of the underlying object. What ACE_Weak_Bound_Ptr does is - * preserve the knowledge that the object is in fact reference - * counted, and thus provides an alternative to raw pointers where - * non-ownership associations must be maintained. When the last - * instance of an ACE_Strong_Bound_Ptr that references a particular - * object is destroyed or overwritten, the corresponding - * ACE_Weak_Bound_Ptr instances are set to NULL. - */ -template -class ACE_Weak_Bound_Ptr -{ -public: - /// Constructor that initializes an ACE_Weak_Bound_Ptr to point to - /// the object \ immediately. - explicit ACE_Weak_Bound_Ptr (X *p = 0); - - /// Copy constructor binds @c this and @a r to the same object. - ACE_Weak_Bound_Ptr (const ACE_Weak_Bound_Ptr &r); - - /// Constructor binds @c this and @a r to the same object. - ACE_Weak_Bound_Ptr (const ACE_Strong_Bound_Ptr &r); - - /// Destructor. - ~ACE_Weak_Bound_Ptr (void); - - /// Assignment operator that binds @c this and @a r to the same object. - void operator = (const ACE_Weak_Bound_Ptr &r); - - /// Assignment operator that binds @c this and @a r to the same object. - void operator = (const ACE_Strong_Bound_Ptr &r); - - /// Equality operator that returns @c true if both - /// ACE_Weak_Bound_Ptr objects point to the same underlying object. - /** - * @note It also returns @c true if both objects have just been - * instantiated and not used yet. - */ - bool operator == (const ACE_Weak_Bound_Ptr &r) const; - - /// Equality operator that returns @c true if the ACE_Weak_Bound_Ptr - /// and ACE_Strong_Bound_Ptr objects point to the same underlying - /// object. - /** - * @note It also returns @c true if both objects have just been - * instantiated and not used yet. - */ - bool operator == (const ACE_Strong_Bound_Ptr &r) const; - - /// Equality operator that returns @c true if the ACE_Weak_Bound_Ptr - /// and the raw pointer point to the same underlying object. - bool operator == (X *p) const; - - /// Inequality operator, which is the opposite of equality. - bool operator != (const ACE_Weak_Bound_Ptr &r) const; - - /// Inequality operator, which is the opposite of equality. - bool operator != (const ACE_Strong_Bound_Ptr &r) const; - - /// Inequality operator, which is the opposite of equality. - bool operator != (X *p) const; - - /// Redirection operator. - /** - * It returns a temporary strong pointer and makes use of the - * chaining properties of operator-> to ensure that the underlying - * object does not disappear while you are using it. If you are - * certain of the lifetimes of the object, and do not want to incur - * the locking overhead, then use the unsafe_get method instead. - */ - ACE_Strong_Bound_Ptr operator-> (void) const; - - /// Obtain a strong pointer corresponding to this weak pointer. This - /// function is useful to create a temporary strong pointer for - /// conversion to a reference. - ACE_Strong_Bound_Ptr strong (void) const; - - /// Get the pointer value. Warning: this does not affect the - /// reference count of the underlying object, so it may disappear on - /// you while you are using it if you are not careful. - X *unsafe_get (void) const; - - /// Resets the ACE_Weak_Bound_Ptr to refer to a different underlying - /// object. - void reset (X *p = 0); - - /// Increment the reference count on the underlying object. - /** - * Returns the new reference count on the object. This function may - * be used to integrate the bound pointers into an external - * reference counting mechanism such as those used by COM or CORBA - * servants. - */ - long add_ref (void); - - /// Decrement the reference count on the underlying object, which is deleted - /// if the count has reached zero. - /** - * Returns the new reference count on the object. This function may - * be used to integrate the bound pointers into an external - * reference counting mechanism such as those used by COM or CORBA - * servants. - */ - long remove_ref (void); - - /// Allows us to check for NULL on all ACE_Weak_Bound_Ptr objects. - bool null (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - typedef X X_t; // This indirection is for Borland C++. - - friend class ACE_Strong_Bound_Ptr; - - /// The ACE_Bound_Ptr_Counter type. - typedef ACE_Bound_Ptr_Counter COUNTER; - - /// The reference counter. - COUNTER *counter_; - - /// The underlying object. - X *ptr_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Bound_Ptr.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Bound_Ptr.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Bound_Ptr.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_BOUND_PTR_H */ diff --git a/deps/acelite/ace/Bound_Ptr.inl b/deps/acelite/ace/Bound_Ptr.inl deleted file mode 100644 index 826c9aa98..000000000 --- a/deps/acelite/ace/Bound_Ptr.inl +++ /dev/null @@ -1,494 +0,0 @@ -/* -*- C++ -*- */ -#include "ace/Guard_T.h" -#if !defined (ACE_NEW_THROWS_EXCEPTIONS) -# include "ace/Log_Category.h" -#endif /* ACE_NEW_THROWS_EXCEPTIONS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template inline ACE_Bound_Ptr_Counter * -ACE_Bound_Ptr_Counter::internal_create (long init_obj_ref_count) -{ - ACE_Bound_Ptr_Counter *temp = 0; - ACE_NEW_RETURN (temp, - ACE_Bound_Ptr_Counter (init_obj_ref_count), - 0); - return temp; -} - -template inline ACE_Bound_Ptr_Counter * -ACE_Bound_Ptr_Counter::create_strong (void) -{ - // Set initial object reference count to 1. - ACE_Bound_Ptr_Counter *temp = internal_create (1); -#if defined (ACE_NEW_THROWS_EXCEPTIONS) - if (temp == 0) - ACE_throw_bad_alloc; -#else - ACE_ASSERT (temp != 0); -#endif /* ACE_NEW_THROWS_EXCEPTIONS */ - return temp; -} - - - -template inline long -ACE_Bound_Ptr_Counter::attach_strong (ACE_Bound_Ptr_Counter* counter) -{ - ACE_GUARD_RETURN (ACE_LOCK, guard, counter->lock_, -1); - - // Can't attach a strong pointer to an object that has already been deleted. - if (counter->obj_ref_count_ == -1) - return -1; - - long new_obj_ref_count = ++counter->obj_ref_count_; - ++counter->self_ref_count_; - - return new_obj_ref_count; -} - -template inline long -ACE_Bound_Ptr_Counter::detach_strong (ACE_Bound_Ptr_Counter* counter) -{ - ACE_Bound_Ptr_Counter *counter_del = 0; - long new_obj_ref_count; - - { - ACE_GUARD_RETURN (ACE_LOCK, guard, counter->lock_, -1); - - if ((new_obj_ref_count = --counter->obj_ref_count_) == 0) - // Change the object reference count to -1 to indicate that the - // object has been deleted, as opposed to a weak pointer that - // simply hasn't had any strong pointers created from it yet. - counter->obj_ref_count_ = -1; - - if (--counter->self_ref_count_ == 0) - // Since counter contains the lock held by the guard, the - // guard needs to be released before freeing the memory holding - // the lock. So save the pointer to free, then release, then - // free. - counter_del = counter; - - } // Release the lock - - delete counter_del; - - return new_obj_ref_count; -} - -template inline ACE_Bound_Ptr_Counter * -ACE_Bound_Ptr_Counter::create_weak (void) -{ - // Set initial object reference count to 0. - - ACE_Bound_Ptr_Counter *temp = internal_create (0); -#if defined (ACE_NEW_THROWS_EXCEPTIONS) - if (temp == 0) - ACE_throw_bad_alloc; -#else - ACE_ASSERT (temp != 0); -#endif /* ACE_NEW_THROWS_EXCEPTIONS */ - return temp; -} - -template inline void -ACE_Bound_Ptr_Counter::attach_weak (ACE_Bound_Ptr_Counter* counter) -{ - ACE_GUARD (ACE_LOCK, guard, counter->lock_); - - ++counter->self_ref_count_; -} - -template inline void -ACE_Bound_Ptr_Counter::detach_weak (ACE_Bound_Ptr_Counter* counter) -{ - ACE_Bound_Ptr_Counter *counter_del = 0; - - { - ACE_GUARD (ACE_LOCK, guard, counter->lock_); - - if (--counter->self_ref_count_ == 0) - // Since counter contains the lock held by the guard, the - // guard needs to be released before freeing the memory holding - // the lock. So save the pointer to free, then release, then - // free. - counter_del = counter; - - } // Release the lock - - delete counter_del; -} - -template inline bool -ACE_Bound_Ptr_Counter::object_was_deleted (ACE_Bound_Ptr_Counter *counter) -{ - ACE_GUARD_RETURN (ACE_LOCK, guard, counter->lock_, 0); - - return counter->obj_ref_count_ == -1; -} - -template inline -ACE_Bound_Ptr_Counter::ACE_Bound_Ptr_Counter (long init_obj_ref_count) - : obj_ref_count_ (init_obj_ref_count), - self_ref_count_ (1) -{ -} - -template inline -ACE_Bound_Ptr_Counter::~ACE_Bound_Ptr_Counter (void) -{ -} - -template inline -ACE_Strong_Bound_Ptr::ACE_Strong_Bound_Ptr (X *p) - : counter_ (COUNTER::create_strong ()), - ptr_ (p) -{ -} - -#if !defined (ACE_HAS_CPP11) -template inline -ACE_Strong_Bound_Ptr::ACE_Strong_Bound_Ptr (auto_ptr p) - : counter_ (COUNTER::create_strong ()), - ptr_ (p.release()) -{ -} -#endif /* !ACE_HAS_CPP11 */ - -template inline -ACE_Strong_Bound_Ptr::ACE_Strong_Bound_Ptr (const ACE_Strong_Bound_Ptr &r) - : counter_ (r.counter_), - ptr_ (r.ptr_) -{ - COUNTER::attach_strong (this->counter_); -} - -template inline -ACE_Strong_Bound_Ptr::ACE_Strong_Bound_Ptr (const ACE_Weak_Bound_Ptr &r) - : counter_ (r.counter_), - ptr_ (r.ptr_) -{ - // When creating a strong pointer from a weak one we can't assume that the - // underlying object still exists. Therefore we must check for a return value - // of -1, which indicates that the object has been destroyed. - if (COUNTER::attach_strong (this->counter_) == -1) - { - // Underlying object has already been deleted, so set this pointer to null. - this->counter_ = COUNTER::create_strong (); - this->ptr_ = 0; - } -} - -template inline -ACE_Strong_Bound_Ptr::~ACE_Strong_Bound_Ptr (void) -{ - if (COUNTER::detach_strong (this->counter_) == 0) - delete this->ptr_; -} - -template inline void -ACE_Strong_Bound_Ptr::operator = (const ACE_Strong_Bound_Ptr &rhs) -{ - // This will work if &r == this, by first increasing the ref count, but - // why go through all that? - if (&rhs == this) - return; - - COUNTER *new_counter = rhs.counter_; - X_t *new_ptr = rhs.ptr_; - COUNTER::attach_strong (new_counter); - if (COUNTER::detach_strong (this->counter_) == 0) - delete this->ptr_; - this->counter_ = new_counter; - this->ptr_ = new_ptr; -} - -template inline void -ACE_Strong_Bound_Ptr::operator = (const ACE_Weak_Bound_Ptr &rhs) -{ - // This will work if &r == this, by first increasing the ref count, but - // why go through all that? - if (&rhs == this) - return; - - COUNTER *new_counter = rhs.counter_; - X_t *new_ptr = rhs.ptr_; - - // When creating a strong pointer from a weak one we can't assume that the - // underlying object still exists. Therefore we must check for a return value - // of -1, which indicates that the object has been destroyed. - if (COUNTER::attach_strong (new_counter) == -1) - { - // Underlying object has already been deleted, so set this pointer to null. - new_counter = COUNTER::create_strong (); - new_ptr = 0; - } - - if (COUNTER::detach_strong (this->counter_) == 0) - delete this->ptr_; - this->counter_ = new_counter; - this->ptr_ = new_ptr; -} - -template inline bool -ACE_Strong_Bound_Ptr::operator== (const ACE_Strong_Bound_Ptr &r) const -{ - return this->ptr_ == r.ptr_; -} - -template inline bool -ACE_Strong_Bound_Ptr::operator== (const ACE_Weak_Bound_Ptr &r) const -{ - // Use the weak pointer's operator== since it will check for null. - return r == *this; -} - -template inline bool -ACE_Strong_Bound_Ptr::operator== (X *p) const -{ - return this->ptr_ == p; -} - -template inline bool -ACE_Strong_Bound_Ptr::operator!= (const ACE_Strong_Bound_Ptr &r) const -{ - return this->ptr_ != r.ptr_; -} - -template inline bool -ACE_Strong_Bound_Ptr::operator!= (const ACE_Weak_Bound_Ptr &r) const -{ - // Use the weak pointer's operator!= since it will check for null. - return r != *this; -} - -template inline bool -ACE_Strong_Bound_Ptr::operator!= (X *p) const -{ - return this->ptr_ != p; -} - -template inline X * -ACE_Strong_Bound_Ptr::operator-> (void) const -{ - return this->ptr_; -} - -template inline X & -ACE_Strong_Bound_Ptr::operator *() const -{ - return *this->ptr_; -} - -template inline X* -ACE_Strong_Bound_Ptr::get (void) const -{ - return this->ptr_; -} - -template inline bool -ACE_Strong_Bound_Ptr::null (void) const -{ - return this->ptr_ == 0; -} - -template inline void -ACE_Strong_Bound_Ptr::reset (X *p) -{ - COUNTER *old_counter = this->counter_; - X_t *old_ptr = this->ptr_; - this->counter_ = COUNTER::create_strong (); - this->ptr_ = p; - if (COUNTER::detach_strong (old_counter) == 0) - delete old_ptr; -} - -#if !defined (ACE_HAS_CPP11) -template inline void -ACE_Strong_Bound_Ptr::reset (auto_ptr p) -{ - COUNTER *old_counter = this->counter_; - X_t *old_ptr = this->ptr_; - this->counter_ = COUNTER::create_strong (); - this->ptr_ = p.release (); - if (COUNTER::detach_strong (old_counter) == 0) - delete old_ptr; -} -#endif /* !ACE_HAS_CPP11 */ - -template inline -ACE_Weak_Bound_Ptr::ACE_Weak_Bound_Ptr (X *p) - : counter_ (COUNTER::create_weak ()), - ptr_ (p) -{ -} - -template inline -ACE_Weak_Bound_Ptr::ACE_Weak_Bound_Ptr (const ACE_Weak_Bound_Ptr &r) - : counter_ (r.counter_), - ptr_ (r.ptr_) -{ - COUNTER::attach_weak (this->counter_); -} - -template inline -ACE_Weak_Bound_Ptr::ACE_Weak_Bound_Ptr (const ACE_Strong_Bound_Ptr &r) - : counter_ (r.counter_), - ptr_ (r.ptr_) -{ - COUNTER::attach_weak (this->counter_); -} - -template inline -ACE_Weak_Bound_Ptr::~ACE_Weak_Bound_Ptr (void) -{ - COUNTER::detach_weak (this->counter_); -} - -template inline void -ACE_Weak_Bound_Ptr::operator = (const ACE_Weak_Bound_Ptr &rhs) -{ - // This will work if &rhs == this, by first increasing the ref count - COUNTER *new_counter = rhs.counter_; - COUNTER::attach_weak (new_counter); - COUNTER::detach_weak (this->counter_); - this->counter_ = new_counter; - this->ptr_ = rhs.ptr_; -} - -template inline void -ACE_Weak_Bound_Ptr::operator = (const ACE_Strong_Bound_Ptr &rhs) -{ - // This will work if &rhs == this, by first increasing the ref count - COUNTER *new_counter = rhs.counter_; - COUNTER::attach_weak (new_counter); - COUNTER::detach_weak (this->counter_); - this->counter_ = new_counter; - this->ptr_ = rhs.ptr_; -} - -template inline bool -ACE_Weak_Bound_Ptr::operator== (const ACE_Weak_Bound_Ptr &r) const -{ - // A weak pointer must behave as though it is automatically set to null - // if the underlying object has been deleted. - if (COUNTER::object_was_deleted (this->counter_)) - return r.ptr_ == 0; - - return this->ptr_ == r.ptr_; -} - -template inline bool -ACE_Weak_Bound_Ptr::operator== (const ACE_Strong_Bound_Ptr &r) const -{ - // A weak pointer must behave as though it is automatically set to null - // if the underlying object has been deleted. - if (COUNTER::object_was_deleted (this->counter_)) - return r.ptr_ == 0; - - return this->ptr_ == r.ptr_; -} - -template inline bool -ACE_Weak_Bound_Ptr::operator== (X *p) const -{ - // A weak pointer must behave as though it is automatically set to null - // if the underlying object has been deleted. - if (COUNTER::object_was_deleted (this->counter_)) - return p == 0; - - return this->ptr_ == p; -} - -template inline bool -ACE_Weak_Bound_Ptr::operator!= (const ACE_Weak_Bound_Ptr &r) const -{ - // A weak pointer must behave as though it is automatically set to null - // if the underlying object has been deleted. - if (COUNTER::object_was_deleted (this->counter_)) - return r.ptr_ != 0; - - return this->ptr_ != r.ptr_; -} - -template inline bool -ACE_Weak_Bound_Ptr::operator!= (const ACE_Strong_Bound_Ptr &r) const -{ - // A weak pointer must behave as though it is automatically set to null - // if the underlying object has been deleted. - if (COUNTER::object_was_deleted (this->counter_)) - return r.ptr_ != 0; - - return this->ptr_ != r.ptr_; -} - -template inline bool -ACE_Weak_Bound_Ptr::operator!= (X *p) const -{ - // A weak pointer must behave as though it is automatically set to null - // if the underlying object has been deleted. - if (COUNTER::object_was_deleted (this->counter_)) - return p != 0; - - return this->ptr_ != p; -} - -template inline ACE_Strong_Bound_Ptr -ACE_Weak_Bound_Ptr::operator-> (void) const -{ - return ACE_Strong_Bound_Ptr (*this); -} - -template inline ACE_Strong_Bound_Ptr -ACE_Weak_Bound_Ptr::strong (void) const -{ - return ACE_Strong_Bound_Ptr (*this); -} - -template inline X* -ACE_Weak_Bound_Ptr::unsafe_get (void) const -{ - // We do not check if the object has been deleted, since this operation - // is defined to be unsafe! - return this->ptr_; -} - -template inline bool -ACE_Weak_Bound_Ptr::null (void) const -{ - // A weak pointer must behave as though it is automatically set to null - // if the underlying object has been deleted. - if (COUNTER::object_was_deleted (this->counter_)) - return true; - - return this->ptr_ == 0; -} - -template inline void -ACE_Weak_Bound_Ptr::reset (X *p) -{ - COUNTER *old_counter = this->counter_; - this->counter_ = COUNTER::create_weak (); - this->ptr_ = p; - COUNTER::detach_weak (old_counter); -} - -template inline long -ACE_Weak_Bound_Ptr::add_ref () -{ - return COUNTER::attach_strong (counter_); -} - -template inline long -ACE_Weak_Bound_Ptr::remove_ref () -{ - long new_obj_ref_count = COUNTER::detach_strong (counter_); - if (new_obj_ref_count == 0) - { - delete this->ptr_; - this->ptr_ = 0; - } - return new_obj_ref_count; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/CDR_Base.cpp b/deps/acelite/ace/CDR_Base.cpp deleted file mode 100644 index b87380ee5..000000000 --- a/deps/acelite/ace/CDR_Base.cpp +++ /dev/null @@ -1,1624 +0,0 @@ -#include "ace/CDR_Base.h" - -#if !defined (__ACE_INLINE__) -# include "ace/CDR_Base.inl" -#endif /* ! __ACE_INLINE__ */ - -#include "ace/Message_Block.h" -#include "ace/OS_Memory.h" -#include "ace/OS_NS_string.h" - -#ifdef ACE_LACKS_IOSTREAM_TOTALLY -#include "ace/OS_NS_stdio.h" -#else -#include "ace/streams.h" -#endif - -#include -#include -#include -#include - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -#if defined (NONNATIVE_LONGDOUBLE) -static const ACE_INT16 max_eleven_bit = 0x3ff; -static const ACE_INT16 max_fifteen_bit = 0x3fff; -#endif /* NONNATIVE_LONGDOUBLE */ - -// -// See comments in CDR_Base.inl about optimization cases for swap_XX_array. -// - -void -ACE_CDR::swap_2_array (char const * orig, char* target, size_t n) -{ - // ACE_ASSERT(n > 0); The caller checks that n > 0 - - // We pretend that AMD64/GNU G++ systems have a Pentium CPU to - // take advantage of the inline assembly implementation. - - // Later, we try to read in 32 or 64 bit chunks, - // so make sure we don't do that for unaligned addresses. -#if ACE_SIZEOF_LONG == 8 && \ - !((defined(__amd64__) || defined (__x86_64__)) && defined(__GNUG__)) - char const * const o8 = ACE_ptr_align_binary (orig, 8); - while (orig < o8 && n > 0) - { - ACE_CDR::swap_2 (orig, target); - orig += 2; - target += 2; - --n; - } -#else - char const * const o4 = ACE_ptr_align_binary (orig, 4); - // this is an _if_, not a _while_. The mismatch can only be by 2. - if (orig != o4) - { - ACE_CDR::swap_2 (orig, target); - orig += 2; - target += 2; - --n; - } -#endif - if (n == 0) - return; - - // - // Loop unrolling. Here be dragons. - // - - // (n & (~3)) is the greatest multiple of 4 not bigger than n. - // In the while loop ahead, orig will move over the array by 8 byte - // increments (4 elements of 2 bytes). - // end marks our barrier for not falling outside. - char const * const end = orig + 2 * (n & (~3)); - - // See if we're aligned for writing in 64 or 32 bit chunks... -#if ACE_SIZEOF_LONG == 8 && \ - !((defined(__amd64__) || defined (__x86_64__)) && defined(__GNUG__)) - if (target == ACE_ptr_align_binary (target, 8)) -#else - if (target == ACE_ptr_align_binary (target, 4)) -#endif - { - while (orig < end) - { -#if defined (ACE_HAS_INTEL_ASSEMBLY) - unsigned int a = - * reinterpret_cast (orig); - unsigned int b = - * reinterpret_cast (orig + 4); - asm ( "bswap %1" : "=r" (a) : "0" (a) ); - asm ( "bswap %1" : "=r" (b) : "0" (b) ); - asm ( "rol $16, %1" : "=r" (a) : "0" (a) ); - asm ( "rol $16, %1" : "=r" (b) : "0" (b) ); - * reinterpret_cast (target) = a; - * reinterpret_cast (target + 4) = b; -#elif defined(ACE_HAS_PENTIUM) \ - && (defined(_MSC_VER) || defined(__BORLANDC__)) \ - && !defined(ACE_LACKS_INLINE_ASSEMBLY) - __asm mov ecx, orig; - __asm mov edx, target; - __asm mov eax, [ecx]; - __asm mov ebx, 4[ecx]; - __asm bswap eax; - __asm bswap ebx; - __asm rol eax, 16; - __asm rol ebx, 16; - __asm mov [edx], eax; - __asm mov 4[edx], ebx; -#elif ACE_SIZEOF_LONG == 8 - // 64 bit architecture. - unsigned long a = * reinterpret_cast (orig); - - unsigned long a1 = (a & 0x00ff00ff00ff00ffUL) << 8; - unsigned long a2 = (a & 0xff00ff00ff00ff00UL) >> 8; - - a = (a1 | a2); - - * reinterpret_cast (target) = a; -#else - ACE_UINT32 a = * reinterpret_cast (orig); - ACE_UINT32 b = * reinterpret_cast (orig + 4); - - ACE_UINT32 a1 = (a & 0x00ff00ffU) << 8; - ACE_UINT32 b1 = (b & 0x00ff00ffU) << 8; - ACE_UINT32 a2 = (a & 0xff00ff00U) >> 8; - ACE_UINT32 b2 = (b & 0xff00ff00U) >> 8; - - a = (a1 | a2); - b = (b1 | b2); - - * reinterpret_cast (target) = a; - * reinterpret_cast (target + 4) = b; -#endif - orig += 8; - target += 8; - } - } - else - { - // We're out of luck. We have to write in 2 byte chunks. - while (orig < end) - { -#if defined (ACE_HAS_INTEL_ASSEMBLY) - unsigned int a = - * reinterpret_cast (orig); - unsigned int b = - * reinterpret_cast (orig + 4); - asm ( "bswap %1" : "=r" (a) : "0" (a) ); - asm ( "bswap %1" : "=r" (b) : "0" (b) ); - // We're little endian. - * reinterpret_cast (target + 2) - = (unsigned short) (a & 0xffff); - * reinterpret_cast (target + 6) - = (unsigned short) (b & 0xffff); - asm ( "shrl $16, %1" : "=r" (a) : "0" (a) ); - asm ( "shrl $16, %1" : "=r" (b) : "0" (b) ); - * reinterpret_cast (target + 0) - = (unsigned short) (a & 0xffff); - * reinterpret_cast (target + 4) - = (unsigned short) (b & 0xffff); -#elif defined (ACE_HAS_PENTIUM) \ - && (defined (_MSC_VER) || defined (__BORLANDC__)) \ - && !defined (ACE_LACKS_INLINE_ASSEMBLY) - __asm mov ecx, orig; - __asm mov edx, target; - __asm mov eax, [ecx]; - __asm mov ebx, 4[ecx]; - __asm bswap eax; - __asm bswap ebx; - // We're little endian. - __asm mov 2[edx], ax; - __asm mov 6[edx], bx; - __asm shr eax, 16; - __asm shr ebx, 16; - __asm mov 0[edx], ax; - __asm mov 4[edx], bx; -#elif ACE_SIZEOF_LONG == 8 - // 64 bit architecture. - unsigned long a = * reinterpret_cast (orig); - - unsigned long a1 = (a & 0x00ff00ff00ff00ffUL) << 8; - unsigned long a2 = (a & 0xff00ff00ff00ff00UL) >> 8; - - a = (a1 | a2); - - ACE_UINT16 b1 = static_cast (a >> 48); - ACE_UINT16 b2 = static_cast ((a >> 32) & 0xffff); - ACE_UINT16 b3 = static_cast ((a >> 16) & 0xffff); - ACE_UINT16 b4 = static_cast (a & 0xffff); - -#if defined(ACE_LITTLE_ENDIAN) - * reinterpret_cast (target) = b4; - * reinterpret_cast (target + 2) = b3; - * reinterpret_cast (target + 4) = b2; - * reinterpret_cast (target + 6) = b1; -#else - * reinterpret_cast (target) = b1; - * reinterpret_cast (target + 2) = b2; - * reinterpret_cast (target + 4) = b3; - * reinterpret_cast (target + 6) = b4; -#endif -#else - ACE_UINT32 a = * reinterpret_cast (orig); - ACE_UINT32 b = * reinterpret_cast (orig + 4); - - ACE_UINT32 a1 = (a & 0x00ff00ff) << 8; - ACE_UINT32 b1 = (b & 0x00ff00ff) << 8; - ACE_UINT32 a2 = (a & 0xff00ff00) >> 8; - ACE_UINT32 b2 = (b & 0xff00ff00) >> 8; - - a = (a1 | a2); - b = (b1 | b2); - - ACE_UINT32 c1 = static_cast (a >> 16); - ACE_UINT32 c2 = static_cast (a & 0xffff); - ACE_UINT32 c3 = static_cast (b >> 16); - ACE_UINT32 c4 = static_cast (b & 0xffff); - -#if defined(ACE_LITTLE_ENDIAN) - * reinterpret_cast (target) = c2; - * reinterpret_cast (target + 2) = c1; - * reinterpret_cast (target + 4) = c4; - * reinterpret_cast (target + 6) = c3; -#else - * reinterpret_cast (target) = c1; - * reinterpret_cast (target + 2) = c2; - * reinterpret_cast (target + 4) = c3; - * reinterpret_cast (target + 6) = c4; -#endif -#endif - - orig += 8; - target += 8; - } - } - - // (n & 3) == (n % 4). - switch (n&3) { - case 3: - ACE_CDR::swap_2 (orig, target); - orig += 2; - target += 2; - // fallthrough - case 2: - ACE_CDR::swap_2 (orig, target); - orig += 2; - target += 2; - // fallthrough - case 1: - ACE_CDR::swap_2 (orig, target); - } -} - -void -ACE_CDR::swap_4_array (char const * orig, char* target, size_t n) -{ - // ACE_ASSERT (n > 0); The caller checks that n > 0 - -#if ACE_SIZEOF_LONG == 8 - // Later, we read from *orig in 64 bit chunks, - // so make sure we don't generate unaligned readings. - char const * const o8 = ACE_ptr_align_binary (orig, 8); - // The mismatch can only be by 4. - if (orig != o8) - { - ACE_CDR::swap_4 (orig, target); - orig += 4; - target += 4; - --n; - } -#endif /* ACE_SIZEOF_LONG == 8 */ - - if (n == 0) - return; - - // - // Loop unrolling. Here be dragons. - // - - // (n & (~3)) is the greatest multiple of 4 not bigger than n. - // In the while loop, orig will move over the array by 16 byte - // increments (4 elements of 4 bytes). - // ends marks our barrier for not falling outside. - char const * const end = orig + 4 * (n & (~3)); - -#if ACE_SIZEOF_LONG == 8 - // 64 bits architecture. - // See if we can write in 8 byte chunks. - if (target == ACE_ptr_align_binary (target, 8)) - { - while (orig < end) - { - unsigned long a = * reinterpret_cast (orig); - unsigned long b = * reinterpret_cast (orig + 8); - -#if defined(ACE_HAS_INTEL_ASSEMBLY) - asm ("bswapq %1" : "=r" (a) : "0" (a)); - asm ("bswapq %1" : "=r" (b) : "0" (b)); - asm ("rol $32, %1" : "=r" (a) : "0" (a)); - asm ("rol $32, %1" : "=r" (b) : "0" (b)); -#else - unsigned long a84 = (a & 0x000000ff000000ffL) << 24; - unsigned long b84 = (b & 0x000000ff000000ffL) << 24; - unsigned long a73 = (a & 0x0000ff000000ff00L) << 8; - unsigned long b73 = (b & 0x0000ff000000ff00L) << 8; - unsigned long a62 = (a & 0x00ff000000ff0000L) >> 8; - unsigned long b62 = (b & 0x00ff000000ff0000L) >> 8; - unsigned long a51 = (a & 0xff000000ff000000L) >> 24; - unsigned long b51 = (b & 0xff000000ff000000L) >> 24; - - a = (a84 | a73 | a62 | a51); - b = (b84 | b73 | b62 | b51); -#endif - - * reinterpret_cast (target) = a; - * reinterpret_cast (target + 8) = b; - - orig += 16; - target += 16; - } - } - else - { - // We are out of luck, we have to write in 4 byte chunks. - while (orig < end) - { - unsigned long a = * reinterpret_cast (orig); - unsigned long b = * reinterpret_cast (orig + 8); - -#if defined(ACE_HAS_INTEL_ASSEMBLY) - asm ("bswapq %1" : "=r" (a) : "0" (a)); - asm ("bswapq %1" : "=r" (b) : "0" (b)); - asm ("rol $32, %1" : "=r" (a) : "0" (a)); - asm ("rol $32, %1" : "=r" (b) : "0" (b)); -#else - unsigned long a84 = (a & 0x000000ff000000ffL) << 24; - unsigned long b84 = (b & 0x000000ff000000ffL) << 24; - unsigned long a73 = (a & 0x0000ff000000ff00L) << 8; - unsigned long b73 = (b & 0x0000ff000000ff00L) << 8; - unsigned long a62 = (a & 0x00ff000000ff0000L) >> 8; - unsigned long b62 = (b & 0x00ff000000ff0000L) >> 8; - unsigned long a51 = (a & 0xff000000ff000000L) >> 24; - unsigned long b51 = (b & 0xff000000ff000000L) >> 24; - - a = (a84 | a73 | a62 | a51); - b = (b84 | b73 | b62 | b51); -#endif - - ACE_UINT32 c1 = static_cast (a >> 32); - ACE_UINT32 c2 = static_cast (a & 0xffffffff); - ACE_UINT32 c3 = static_cast (b >> 32); - ACE_UINT32 c4 = static_cast (b & 0xffffffff); - -#if defined (ACE_LITTLE_ENDIAN) - * reinterpret_cast (target + 0) = c2; - * reinterpret_cast (target + 4) = c1; - * reinterpret_cast (target + 8) = c4; - * reinterpret_cast (target + 12) = c3; -#else - * reinterpret_cast (target + 0) = c1; - * reinterpret_cast (target + 4) = c2; - * reinterpret_cast (target + 8) = c3; - * reinterpret_cast (target + 12) = c4; -#endif - orig += 16; - target += 16; - } - } - -#else /* ACE_SIZEOF_LONG != 8 */ - - while (orig < end) - { -#if defined (ACE_HAS_PENTIUM) && defined (__GNUG__) - unsigned int a = *reinterpret_cast (orig); - unsigned int b = *reinterpret_cast (orig + 4); - unsigned int c = *reinterpret_cast (orig + 8); - unsigned int d = *reinterpret_cast (orig + 12); - - asm ("bswap %1" : "=r" (a) : "0" (a)); - asm ("bswap %1" : "=r" (b) : "0" (b)); - asm ("bswap %1" : "=r" (c) : "0" (c)); - asm ("bswap %1" : "=r" (d) : "0" (d)); - - *reinterpret_cast (target) = a; - *reinterpret_cast (target + 4) = b; - *reinterpret_cast (target + 8) = c; - *reinterpret_cast (target + 12) = d; -#elif defined (ACE_HAS_PENTIUM) \ - && (defined (_MSC_VER) || defined (__BORLANDC__)) \ - && !defined (ACE_LACKS_INLINE_ASSEMBLY) - __asm mov eax, orig - __asm mov esi, target - __asm mov edx, [eax] - __asm mov ecx, 4[eax] - __asm mov ebx, 8[eax] - __asm mov eax, 12[eax] - __asm bswap edx - __asm bswap ecx - __asm bswap ebx - __asm bswap eax - __asm mov [esi], edx - __asm mov 4[esi], ecx - __asm mov 8[esi], ebx - __asm mov 12[esi], eax -#else - ACE_UINT32 a = * reinterpret_cast (orig); - ACE_UINT32 b = * reinterpret_cast (orig + 4); - ACE_UINT32 c = * reinterpret_cast (orig + 8); - ACE_UINT32 d = * reinterpret_cast (orig + 12); - - // Expect the optimizer reordering this A LOT. - // We leave it this way for clarity. - a = (a << 24) | ((a & 0xff00) << 8) | ((a & 0xff0000) >> 8) | (a >> 24); - b = (b << 24) | ((b & 0xff00) << 8) | ((b & 0xff0000) >> 8) | (b >> 24); - c = (c << 24) | ((c & 0xff00) << 8) | ((c & 0xff0000) >> 8) | (c >> 24); - d = (d << 24) | ((d & 0xff00) << 8) | ((d & 0xff0000) >> 8) | (d >> 24); - - * reinterpret_cast (target) = a; - * reinterpret_cast (target + 4) = b; - * reinterpret_cast (target + 8) = c; - * reinterpret_cast (target + 12) = d; -#endif - - orig += 16; - target += 16; - } - -#endif /* ACE_SIZEOF_LONG == 8 */ - - // (n & 3) == (n % 4). - switch (n & 3) { - case 3: - ACE_CDR::swap_4 (orig, target); - orig += 4; - target += 4; - // fallthrough - case 2: - ACE_CDR::swap_4 (orig, target); - orig += 4; - target += 4; - // fallthrough - case 1: - ACE_CDR::swap_4 (orig, target); - } -} - -// -// We don't benefit from unrolling in swap_8_array and swap_16_array -// (swap_8 and swap_16 are big enough). -// -void -ACE_CDR::swap_8_array (char const * orig, char* target, size_t n) -{ - // ACE_ASSERT(n > 0); The caller checks that n > 0 - - char const * const end = orig + 8*n; - while (orig < end) - { - swap_8 (orig, target); - orig += 8; - target += 8; - } -} - -void -ACE_CDR::swap_16_array (char const * orig, char* target, size_t n) -{ - // ACE_ASSERT(n > 0); The caller checks that n > 0 - - char const * const end = orig + 16*n; - while (orig < end) - { - swap_16 (orig, target); - orig += 16; - target += 16; - } -} - -void -ACE_CDR::mb_align (ACE_Message_Block *mb) -{ -#if !defined (ACE_CDR_IGNORE_ALIGNMENT) - char * const start = ACE_ptr_align_binary (mb->base (), - ACE_CDR::MAX_ALIGNMENT); -#else - char * const start = mb->base (); -#endif /* ACE_CDR_IGNORE_ALIGNMENT */ - mb->rd_ptr (start); - mb->wr_ptr (start); -} - -int -ACE_CDR::grow (ACE_Message_Block *mb, size_t minsize) -{ - size_t newsize = - ACE_CDR::first_size (minsize + ACE_CDR::MAX_ALIGNMENT); - - if (newsize <= mb->size ()) - return 0; - - ACE_Data_Block *db = - mb->data_block ()->clone_nocopy (0, newsize); - - if (db == 0) - return -1; - - // Do the equivalent of ACE_CDR::mb_align() here to avoid having - // to allocate an ACE_Message_Block on the stack thereby avoiding - // the manipulation of the data blocks reference count - size_t mb_len = mb->length (); - char *start = ACE_ptr_align_binary (db->base (), - ACE_CDR::MAX_ALIGNMENT); - - ACE_OS::memcpy (start, mb->rd_ptr (), mb_len); - mb->data_block (db); - - // Setting the data block on the mb resets the read and write - // pointers back to the beginning. We must set the rd_ptr to the - // aligned start and adjust the write pointer to the end - mb->rd_ptr (start); - mb->wr_ptr (start + mb_len); - - // Remove the DONT_DELETE flags from mb - mb->clr_self_flags (ACE_Message_Block::DONT_DELETE); - - return 0; -} - -size_t -ACE_CDR::total_length (const ACE_Message_Block* begin, - const ACE_Message_Block* end) -{ - size_t l = 0; - // Compute the total size. - for (const ACE_Message_Block *i = begin; - i != end; - i = i->cont ()) - l += i->length (); - return l; -} - -int -ACE_CDR::consolidate (ACE_Message_Block *dst, - const ACE_Message_Block *src) -{ - if (src == 0) - return 0; - - size_t const newsize = - ACE_CDR::first_size (ACE_CDR::total_length (src, 0) - + ACE_CDR::MAX_ALIGNMENT); - - if (dst->size (newsize) == -1) - return -1; - -#if !defined (ACE_CDR_IGNORE_ALIGNMENT) - // We must copy the contents of src into the new buffer, but - // respecting the alignment. - ptrdiff_t srcalign = - ptrdiff_t(src->rd_ptr ()) % ACE_CDR::MAX_ALIGNMENT; - ptrdiff_t dstalign = - ptrdiff_t(dst->rd_ptr ()) % ACE_CDR::MAX_ALIGNMENT; - ptrdiff_t offset = srcalign - dstalign; - if (offset < 0) - offset += ACE_CDR::MAX_ALIGNMENT; - dst->rd_ptr (static_cast (offset)); - dst->wr_ptr (dst->rd_ptr ()); -#endif /* ACE_CDR_IGNORE_ALIGNMENT */ - - for (const ACE_Message_Block* i = src; - i != 0; - i = i->cont ()) - { - // If the destination and source are the same, do not - // attempt to copy the data. Just update the write pointer. - if (dst->wr_ptr () != i->rd_ptr ()) - dst->copy (i->rd_ptr (), i->length ()); - else - dst->wr_ptr (i->length ()); - } - return 0; -} - -#if defined (NONNATIVE_LONGDOUBLE) -ACE_CDR::LongDouble& -ACE_CDR::LongDouble::assign (const ACE_CDR::LongDouble::NativeImpl& rhs) -{ - ACE_OS::memset (this->ld, 0, sizeof (this->ld)); - - if (sizeof (rhs) == 8) - { -#if defined (ACE_LITTLE_ENDIAN) - static const size_t byte_zero = 1; - static const size_t byte_one = 0; - char rhs_ptr[16]; - ACE_CDR::swap_8 (reinterpret_cast (&rhs), rhs_ptr); -#else - static const size_t byte_zero = 0; - static const size_t byte_one = 1; - const char* rhs_ptr = reinterpret_cast (&rhs); -#endif - ACE_INT16 sign = static_cast ( - static_cast (rhs_ptr[0])) & 0x8000; - ACE_INT16 exponent = ((rhs_ptr[0] & 0x7f) << 4) | - ((rhs_ptr[1] >> 4) & 0xf); - const char* exp_ptr = reinterpret_cast (&exponent); - - // Infinity and NaN have an exponent of 0x7ff in 64-bit IEEE - if (exponent == 0x7ff) - { - exponent = 0x7fff; - } - else if (exponent) // exponent 0 stays 0 in 128-bit - { - exponent = (exponent - max_eleven_bit) + max_fifteen_bit; - } - exponent |= sign; - - // Store the sign bit and exponent - this->ld[0] = exp_ptr[byte_zero]; - this->ld[1] = exp_ptr[byte_one]; - - // Store the mantissa. In an 8 byte double, it is split by - // 4 bits (because of the 12 bits for sign and exponent), so - // we have to shift and or the rhs to get the right bytes. - size_t li = 2; - bool direction = true; - for (size_t ri = 1; ri < sizeof (rhs);) - { - if (direction) - { - this->ld[li] |= ((rhs_ptr[ri] << 4) & 0xf0); - direction = false; - ++ri; - } - else - { - this->ld[li] |= ((rhs_ptr[ri] >> 4) & 0xf); - direction = true; - ++li; - } - } -#if defined (ACE_LITTLE_ENDIAN) - ACE_OS::memcpy (rhs_ptr, this->ld, sizeof (this->ld)); - ACE_CDR::swap_16 (rhs_ptr, this->ld); -#endif - } - else - { - ACE_OS::memcpy(this->ld, - reinterpret_cast (&rhs), sizeof (rhs)); - } - return *this; -} - -ACE_CDR::LongDouble& -ACE_CDR::LongDouble::assign (const ACE_CDR::LongDouble& rhs) -{ - if (this != &rhs) - *this = rhs; - return *this; -} - -bool -ACE_CDR::LongDouble::operator== (const ACE_CDR::LongDouble &rhs) const -{ - return ACE_OS::memcmp (this->ld, rhs.ld, 16) == 0; -} - -bool -ACE_CDR::LongDouble::operator!= (const ACE_CDR::LongDouble &rhs) const -{ - return ACE_OS::memcmp (this->ld, rhs.ld, 16) != 0; -} - -ACE_CDR::LongDouble::operator ACE_CDR::LongDouble::NativeImpl () const -{ - ACE_CDR::LongDouble::NativeImpl ret = 0.0; - char* lhs_ptr = reinterpret_cast (&ret); - - if (sizeof (ret) == 8) - { -#if defined (ACE_LITTLE_ENDIAN) - static const size_t byte_zero = 1; - static const size_t byte_one = 0; - char copy[16]; - ACE_CDR::swap_16 (this->ld, copy); -#else - static const size_t byte_zero = 0; - static const size_t byte_one = 1; - const char* copy = this->ld; -#endif - ACE_INT16 exponent = 0; - char* exp_ptr = reinterpret_cast (&exponent); - exp_ptr[byte_zero] = copy[0]; - exp_ptr[byte_one] = copy[1]; - - ACE_INT16 sign = (exponent & 0x8000); - exponent &= 0x7fff; - - // Infinity and NaN have an exponent of 0x7fff in 128-bit IEEE - if (exponent == 0x7fff) - { - exponent = 0x7ff; - } - else if (exponent) // exponent 0 stays 0 in 64-bit - { - exponent = (exponent - max_fifteen_bit) + max_eleven_bit; - } - exponent = (exponent << 4) | sign; - - // Store the sign and exponent - lhs_ptr[0] = exp_ptr[byte_zero]; - lhs_ptr[1] = exp_ptr[byte_one]; - - // Store the mantissa. In an 8 byte double, it is split by - // 4 bits (because of the 12 bits for sign and exponent), so - // we have to shift and or the rhs to get the right bytes. - size_t li = 1; - bool direction = true; - for (size_t ri = 2; li < sizeof (ret);) { - if (direction) - { - lhs_ptr[li] |= ((copy[ri] >> 4) & 0xf); - direction = false; - ++li; - } - else - { - lhs_ptr[li] |= ((copy[ri] & 0xf) << 4); - direction = true; - ++ri; - } - } - -#if defined (ACE_LITTLE_ENDIAN) - ACE_CDR::swap_8 (lhs_ptr, lhs_ptr); -#endif - } - else - { - ACE_OS::memcpy(lhs_ptr, this->ld, sizeof (ret)); - } - - // This bit of code is unnecessary. However, this code is - // necessary to work around a bug in the gcc 4.1.1 optimizer. - ACE_CDR::LongDouble tmp; - tmp.assign (ret); - - return ret; -} -#endif /* NONNATIVE_LONGDOUBLE */ - - -// ACE_CDR::Fixed - -ACE_CDR::Fixed ACE_CDR::Fixed::from_integer (ACE_CDR::LongLong val) -{ - Fixed f; - f.value_[15] = (val < 0) ? NEGATIVE : POSITIVE; - f.digits_ = 0; - f.scale_ = 0; - bool high = true; - int idx = 15; - while (true) - { - const int mod = static_cast (val % 10); - const unsigned int digit = (mod < 0) ? -mod : mod; - if (high) - f.value_[idx--] |= digit << 4; - else - f.value_[idx] = digit; - high = !high; - ++f.digits_; - if (val >= 10 || val <= -10) - val /= 10; - else - break; - } - - ACE_OS::memset (f.value_, 0, idx + !high); - return f; -} - -ACE_CDR::Fixed ACE_CDR::Fixed::from_integer (ACE_CDR::ULongLong val) -{ - Fixed f; - f.value_[15] = POSITIVE; - f.digits_ = 0; - f.scale_ = 0; - bool high = true; - int idx = 15; - while (true) - { - const unsigned int digit = val % 10; - if (high) - f.value_[idx--] |= digit << 4; - else - f.value_[idx] = digit; - high = !high; - ++f.digits_; - if (val >= 10) - val /= 10; - else - break; - } - - ACE_OS::memset (f.value_, 0, idx + !high); - return f; -} - -ACE_CDR::Fixed ACE_CDR::Fixed::from_floating (LongDouble val) -{ -#if defined ACE_OPENVMS || (defined ACE_VXWORKS && !defined __RTP__) - typedef double BigFloat; -#elif defined NONNATIVE_LONGDOUBLE - typedef LongDouble::NativeImpl BigFloat; -#else - typedef LongDouble BigFloat; -#endif - - Fixed f; - f.digits_ = f.scale_ = 0; - bool negative = false; - if (val < 0) - { - val *= -1; - negative = true; - } - - // How many digits are to the left of the decimal point? - const size_t digits_left = - static_cast (1 + ((val > 0) ? std::log10 (val) : 0)); - if (digits_left > MAX_DIGITS) - { - ACE_OS::memset (f.value_, 0, sizeof f.value_); - return f; - } - - f.digits_ = MAX_DIGITS; - f.scale_ = 0; - BigFloat int_part; - BigFloat frac_part = std::modf (val, &int_part); - - // Insert the integer part from least to most significant - int idx = (static_cast (digits_left) + 1) / 2 - 1; - bool high = digits_left % 2; - if (idx >= 0) - f.value_[idx] = 0; - for (size_t i = 0; i < digits_left; ++i, high = !high) - { - const Octet digit = static_cast (std::fmod (int_part, 10)); - if (high) - f.value_[idx--] |= digit << 4; - else - f.value_[idx] = digit; - int_part /= 10; - } - - // Insert the fractional part from most to least significant - idx = static_cast (digits_left / 2); - high = digits_left % 2 == 0; - for (size_t i = digits_left; i < MAX_DIGITS; ++i, high = !high) - { - frac_part *= 10; - const Octet digit = static_cast (frac_part); - frac_part -= digit; - if (high) - f.value_[idx] = digit << 4; - else - f.value_[idx++] |= digit; - } - - if (frac_part >= 0.5) - ++f; // scale set after here so that ++ applies to the fractional part - - f.scale_ = static_cast (MAX_DIGITS - digits_left); - f.normalize (); - f.value_[15] |= negative ? NEGATIVE : POSITIVE; - return f; -} - -void ACE_CDR::Fixed::normalize (UShort min_scale) -{ - if (this->value_[15] & 0xf0 || !this->scale_) - return; - - // Calculate the number of nibbles that can be moved. - ACE_CDR::Octet nibbles = 0; - while (this->digit(nibbles) == 0 && this->scale_ - nibbles > min_scale) - ++nibbles; - - // Move and clear the nibbles. - for (ACE_CDR::Octet idx = nibbles; idx != this->digits_; ++idx) { - this->digit (idx - nibbles, this->digit (idx)); - this->digit (idx, 0); - } - - this->scale_ -= nibbles; - this->digits_ -= nibbles; -} - -ACE_CDR::Fixed ACE_CDR::Fixed::from_string (const char *str) -{ - const bool negative = *str == '-'; - if (negative || *str == '+') - ++str; - - const size_t span = ACE_OS::strspn (str, ".0123456789"); - - Fixed f; - f.value_[15] = negative ? NEGATIVE : POSITIVE; - f.digits_ = 0; - f.scale_ = 0; - - int idx = 15; - bool high = true; - for (size_t iter = span; iter && f.digits_ < MAX_DIGITS; --iter, high = !high) - { - if (str[iter - 1] == '.') - { - f.scale_ = static_cast (span - iter); - if (--iter == 0) - break; // skip '.' - } - - const unsigned int digit = str[iter - 1] - '0'; - if (high) - f.value_[idx--] |= digit << 4; - else - f.value_[idx] = digit; - ++f.digits_; - } - - if (!f.scale_ && str[span - f.digits_ - 1] == '.') - f.scale_ = f.digits_; - - if (idx >= 0) - ACE_OS::memset (f.value_, 0, idx + !high); - return f; -} - -ACE_CDR::Fixed ACE_CDR::Fixed::from_octets (const Octet *array, int len, - unsigned int scale) -{ - Fixed f; - ACE_OS::memcpy (f.value_ + 16 - len, array, len); - ACE_OS::memset (f.value_, 0, 16 - len); - f.scale_ = scale; - - f.digits_ = len * 2 - 1; - if (len > 1 && (array[0] >> 4) == 0) - --f.digits_; - - return f; -} - -ACE_CDR::Fixed::operator ACE_CDR::LongLong () const -{ - LongLong val (0); - - for (int i = this->digits_ - 1; i >= this->scale_; --i) - val = 10 * val + this->digit (i); - - if (this->sign ()) - val *= -1; - - return val; -} - -ACE_CDR::Fixed::operator ACE_CDR::LongDouble () const -{ - LongDouble val = ACE_CDR_LONG_DOUBLE_INITIALIZER; - - for (int i = this->digits_ - 1; i >= this->scale_; --i) - ACE_CDR_LONG_DOUBLE_ASSIGNMENT (val, 10 * val + this->digit (i)); - - for (int i = this->scale_ - 1; i >= 0; --i) - val += this->digit (i) * std::pow (10.0l, i - this->scale_); - - if (this->sign ()) - val *= -1; - - return val; -} - -ACE_CDR::Fixed ACE_CDR::Fixed::round (UShort scale) const -{ - Fixed f = *this; - if (scale < f.scale_) - { - for (UShort i = 0; i < f.scale_ - scale; ++i) - f.digit (i, 0); - f.normalize (scale); - const bool negative = f.sign (); - if (negative) - f.value_[15] = (f.value_[15] & 0xf0) | POSITIVE; - if (this->digit (this->scale_ - scale - 1) >= 5) - { - f.scale_ = 0; - ++f; - f.scale_ = static_cast (scale); - } - if (negative && !!f) - f.value_[15] = (f.value_[15] & 0xf0) | NEGATIVE; - } - return f; -} - -ACE_CDR::Fixed ACE_CDR::Fixed::truncate (UShort scale) const -{ - Fixed f = *this; - if (scale < f.scale_) - { - for (UShort i = 0; i < f.scale_ - scale; ++i) - f.digit (i, 0); - f.normalize (scale); - if (f.sign ()) - { - f.value_[15] = (f.value_[15] & 0xf0) | POSITIVE; - if (!!f) - f.value_[15] = (f.value_[15] & 0xf0) | NEGATIVE; - } - } - return f; -} - -namespace { - struct BufferAppender - { - BufferAppender (char *buffer, size_t buffer_size) - : buffer_ (buffer), buffer_size_ (buffer_size), idx_ (0) {} - - bool operator+= (char ch) - { - if (this->idx_ == this->buffer_size_ - 1) - return false; - this->buffer_[this->idx_++] = ch; - return true; - } - - char *const buffer_; - const size_t buffer_size_; - size_t idx_; - }; -} - -bool ACE_CDR::Fixed::to_string (char *buffer, size_t buffer_size) const -{ - if (!buffer || buffer_size < 2) - return false; - - const bool negative = this->sign (); - if (negative) - *buffer = '-'; - BufferAppender ba (buffer + negative, buffer_size - negative); - - for (int i = 15 - this->digits_ / 2; i < 16; ++i) - { - const Octet high = this->value_[i] >> 4, low = this->value_[i] & 0xf; - - if ((15 - i) * 2 != this->digits_) - { - if (this->scale_ == 1 + 2 * (15 - i)) - { - if (!ba.idx_ && !(ba += '0')) - return false; - - if (!(ba += '.')) - return false; - } - - if ((ba.idx_ || high) && !(ba += '0' + high)) - return false; - } - - if (this->scale_ && this->scale_ == 2 * (15 - i)) - { - if (!ba.idx_ && !(ba += '0')) - return false; - - if (!(ba += '.')) - return false; - } - - if (i < 15 && (ba.idx_ || low) && !(ba += '0' + low)) - return false; - } - - if (!ba.idx_ && !(ba += '0')) - return false; - - buffer[ba.idx_ + negative] = 0; - return true; -} - -const ACE_CDR::Octet *ACE_CDR::Fixed::to_octets (int &n) const -{ - n = (this->digits_ + 2) / 2; - return 16 - n + reinterpret_cast (this->value_); -} - -ACE_CDR::Fixed::ConstIterator ACE_CDR::Fixed::pre_add (const ACE_CDR::Fixed &f) -{ - ConstIterator rhs_iter = f.begin (); - if (f.scale_ > this->scale_) - { - const int scale_diff = f.scale_ - this->scale_; - rhs_iter += scale_diff - this->lshift (scale_diff); - } - - if (f.digits_ - f.scale_ > this->digits_ - this->scale_) - { - ACE_CDR::Octet new_digits = this->digits_ + (f.digits_ - f.scale_) - (this->digits_ - this->scale_); - if (new_digits > MAX_DIGITS) - { - for (size_t i = 0; i < static_cast (new_digits - MAX_DIGITS); ++i) - this->digit (static_cast (i), 0); - this->normalize (this->scale_ - (new_digits - MAX_DIGITS)); - this->digits_ = MAX_DIGITS; - } - else - this->digits_ = new_digits; - } - return rhs_iter; -} - -ACE_CDR::Fixed &ACE_CDR::Fixed::operator+= (const Fixed &rhs) -{ - if (!this->sign () && rhs.sign ()) - return *this -= -rhs; - - if (this->sign () && !rhs.sign ()) - { - Fixed negated = -*this; - negated -= rhs; - return *this = -negated; - } - - ConstIterator rhs_iter = this->pre_add (rhs); - - Iterator lhs_iter = this->begin (); - if (this->scale_ > rhs.scale_) - lhs_iter += this->scale_ - rhs.scale_; - - bool carry = false; - for (; rhs_iter != rhs.end (); ++lhs_iter, ++rhs_iter) - { - const Octet digit = *lhs_iter + *rhs_iter + carry; - carry = digit > 9; - *lhs_iter = digit - (carry ? 10 : 0); - } - - if (carry) - { - if (this->digits_ < MAX_DIGITS) - { - *lhs_iter = 1; - ++this->digits_; - } - else if (this->scale_) - { - this->digit (0, 0); - this->normalize (this->scale_ - 1); - this->digit (MAX_DIGITS - 1, 1); - } - } - - return *this; -} - -int ACE_CDR::Fixed::lshift (int digits) -{ - int bytes = 0; - for (; bytes < digits / 2; ++bytes) - if (this->value_[bytes]) - break; - - int shifted = 0; - if ((digits % 2) && !(this->value_[bytes] & 0xf0)) - { - for (int i = 0; i < 15 - bytes; ++i) - this->value_[i] = (this->value_[i + bytes] & 0xf) << 4 - | (this->value_[i + bytes + 1] >> 4); - std::memset (this->value_ + 15 - bytes, 0, bytes); - this->value_[15] &= 0xf; - shifted = 2 * bytes + 1; - } - else if (bytes) - { - std::memmove (this->value_, this->value_ + bytes, 16 - bytes); - this->value_[15] &= 0xf; - std::memset (this->value_ + 16 - bytes, 0, bytes - 1); - this->value_[15 - bytes] &= 0xf0; - shifted = 2 * bytes; - } - - this->digits_ += shifted; - if (this->digits_ > MAX_DIGITS) - this->digits_ = MAX_DIGITS; - - this->scale_ += shifted; - if (this->scale_ > MAX_DIGITS) - this->scale_ = MAX_DIGITS; - - return shifted; -} - -ACE_CDR::Fixed &ACE_CDR::Fixed::operator-= (const Fixed &rhs) -{ - if (!this->sign () && rhs.sign ()) - return *this += -rhs; - - if (this->sign () && !rhs.sign ()) - { - Fixed negated = -*this; - negated += rhs; - return *this = -negated; - } - - const Fixed before = *this; - ConstIterator rhs_iter = this->pre_add (rhs); - - Iterator lhs_iter = this->begin (); - if (this->scale_ > rhs.scale_) - lhs_iter += this->scale_ - rhs.scale_; - - bool borrow = false; - for (; rhs_iter != rhs.end (); ++lhs_iter, ++rhs_iter) - if (*rhs_iter + borrow <= *lhs_iter) - { - *lhs_iter -= *rhs_iter + borrow; - borrow = false; - } - else - { - *lhs_iter += 10 - *rhs_iter - borrow; - borrow = true; - } - - while (borrow && lhs_iter != this->end ()) - if (*lhs_iter) - { - --*lhs_iter; - borrow = false; - } - else - *lhs_iter = 9; - - if (borrow) - return *this = -(rhs - before); - - this->ltrim (); - return *this; -} - -ACE_CDR::Fixed &ACE_CDR::Fixed::operator*= (const Fixed &rhs) -{ - if (!this->sign () && rhs.sign ()) - this->value_[15] = (this->value_[15] & 0xf0) | NEGATIVE; - else if (this->sign () && rhs.sign ()) - this->value_[15] = (this->value_[15] & 0xf0) | POSITIVE; - - this->ltrim (); - Fixed right = rhs; - right.ltrim (); - - Octet temp[MAX_DIGITS * 2]; - int carry = 0; - - for (int col = 0; col < this->digits_ + right.digits_; ++col) - { - for (int row = (std::max) (0, col - this->digits_ + 1); - row < (std::min) (col + 1, int (right.digits_)); ++row) - carry += this->digit (col - row) * right.digit (row); - temp[col] = carry % 10; - carry /= 10; - } - - this->digits_ += right.digits_; - this->scale_ += right.scale_; - int digit_offset = 0; - - if (this->digits_ > MAX_DIGITS) - { - digit_offset = this->digits_ - MAX_DIGITS; - this->digits_ = MAX_DIGITS; - if (this->scale_ > digit_offset) - this->scale_ -= digit_offset; - } - - for (int i = 0; i < this->digits_; ++i) - this->digit (i, temp[i + digit_offset]); - - this->ltrim (); - return *this; -} - -ACE_CDR::Fixed &ACE_CDR::Fixed::operator/= (const Fixed &rhs) -{ - if (!rhs) - return *this; - - if (rhs.scale_ && rhs.scale_ <= this->scale_) - this->scale_ -= rhs.scale_; - else if (rhs.scale_) - { - const Octet shifted = this->lshift (rhs.scale_ - this->scale_); - this->scale_ -= shifted; - } - - Fixed rhs_no_scale = rhs; - rhs_no_scale.scale_ = 0; - rhs_no_scale.value_[15] = (rhs_no_scale.value_[15] & 0xf0) | POSITIVE; - rhs_no_scale.ltrim (); - - this->ltrim (); - - if (!this->sign () && rhs.sign ()) - this->value_[15] = (this->value_[15] & 0xf0) | NEGATIVE; - else if (this->sign () && rhs.sign ()) - this->value_[15] = (this->value_[15] & 0xf0) | POSITIVE; - - static const Fixed one = from_integer (LongLong (1)), - two = from_integer (LongLong (2)), - three = from_integer (LongLong (3)), - five = from_integer (LongLong (5)); - - if (rhs_no_scale == one) - return *this; - - // Most sig digit of rhs must be >= 5 - switch (rhs_no_scale.digit (rhs_no_scale.digits_ - 1)) - { - case 1: - return *this = (*this * five) / (rhs_no_scale * five); - case 2: - return *this = (*this * three) / (rhs_no_scale * three); - case 3: - case 4: - return *this = (*this * two) / (rhs_no_scale * two); - default: - break; - } - - const bool neg = this->sign (); - if (neg) - this->value_[15] = (this->value_[15] & 0xf0) | POSITIVE; - - Fixed r; - Fixed q = this->div_helper2 (rhs_no_scale, r); - q.scale_ = this->scale_; - - if (!r) { - *this = neg ? -q : q; - this->normalize (); - return *this; - } - - const int shift = q.lshift (MAX_DIGITS); - if (shift) - { - const Octet scale = r.lshift (shift); - r.scale_ = 0; - Fixed r2; - r = r.div_helper2 (rhs_no_scale, r2); - r.scale_ = scale; - q += r; - } - - *this = neg ? -q : q; - this->normalize (); - return *this; -} - -ACE_CDR::Fixed ACE_CDR::Fixed::div_helper2 (const Fixed &rhs, Fixed &r) const -{ - if (this->digits_ < rhs.digits_) - r = *this; - else if (this->digits_ == rhs.digits_) - if (*this < rhs) - r = *this; - else - { - r = *this - rhs; - return from_integer (LongLong (1)); - } - else if (this->digits_ == rhs.digits_ + 1) - return this->div_helper1 (rhs, r); - else - { - const int dig = this->digits_ - rhs.digits_ - 1; - Fixed top = *this, bot = *this; // split with bot having dig digits - for (int i = 0; i < dig; ++i) - top.digit (i, 0); - for (int i = dig; i < this->digits_; ++i) - bot.digit (i, 0); - bot.digits_ = dig; - top.scale_ += dig; - top.normalize (this->scale_); - - Fixed rtop; - const Fixed qtop = top.div_helper1 (rhs, rtop); - const Fixed qbot = rtop.join (dig, bot).div_helper2 (rhs, r); - return qtop.join (dig, qbot); - } - - return from_integer (); -} - -ACE_CDR::Fixed ACE_CDR::Fixed::div_helper1 (const Fixed &rhs, Fixed &r) const -{ - static const Fixed ten = from_integer (LongLong (10)); - if (*this >= rhs * ten) - return ten + (*this - rhs * ten).div_helper1 (rhs, r); - - int q = (this->digit (this->digits_ - 1) * 10 + - this->digit (this->digits_ - 2)) / rhs.digit (rhs.digits_ - 1); - if (q > 9) - q = 9; - Fixed t = from_integer (LongLong (q)) * rhs; - t.scale_ = this->scale_; - for (int i = 0; i < 2 && t > *this; ++i) - { - --q; - t -= rhs; - } - - r = *this - t; - return from_integer (LongLong (q)); -} - -ACE_CDR::Fixed ACE_CDR::Fixed::join (int digits, const Fixed &bot) const -{ - Fixed res = bot; - res.digits_ = this->digits_ + digits; - for (int i = digits; i < MAX_DIGITS && i - digits < this->digits_; ++i) - res.digit (i, this->digit (i - digits)); - return res; -} - -ACE_CDR::Fixed &ACE_CDR::Fixed::operator++ () -{ - if (this->sign ()) - { - this->value_[15] = (this->value_[15] & 0xf0) | POSITIVE; - if (!!--*this) // decrement and check if result is nonzero - this->value_[15] = (this->value_[15] & 0xf0) | NEGATIVE; - } - else - { - Iterator iter = this->begin (); - iter += this->scale_; - for (; iter != this->end (); ++iter) - { - if (*iter < 9) - { - ++*iter; - return *this; - } - *iter = 0; - } - if (this->digits_ < MAX_DIGITS) - { - ++this->digits_; - *iter = 1; - } - } - return *this; -} - -ACE_CDR::Fixed &ACE_CDR::Fixed::operator-- () -{ - if (this->sign ()) - { - this->value_[15] = (this->value_[15] & 0xf0) | POSITIVE; - ++*this; - this->value_[15] = (this->value_[15] & 0xf0) | NEGATIVE; - } - else - { - Fixed before = *this; - Iterator iter = this->begin (); - iter += this->scale_; - for (; iter != this->end (); ++iter) - { - if (*iter) - { - --*iter; - return *this; - } - *iter = 9; - } - *this = before - from_integer (ULongLong (1)); - } - return *this; -} - -bool ACE_CDR::Fixed::operator! () const -{ - static const Octet ZERO[] = {0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, POSITIVE}; - return 0 == ACE_OS::memcmp (this->value_, ZERO, sizeof ZERO); -} - -ACE_OSTREAM_TYPE &operator<< (ACE_OSTREAM_TYPE &lhs, const ACE_CDR::Fixed &rhs) -{ - char digits[ACE_CDR::Fixed::MAX_STRING_SIZE]; - rhs.to_string (digits, sizeof digits); - -#ifdef ACE_LACKS_IOSTREAM_TOTALLY - ACE_OS::fputs (digits, &lhs); -#else - lhs << digits; -#endif - return lhs; -} - -#ifndef ACE_LACKS_IOSTREAM_TOTALLY -std::istream &operator>> (std::istream &lhs, ACE_CDR::Fixed &rhs) -{ - double num; - lhs >> num; - ACE_CDR::LongDouble ld; - ACE_CDR_LONG_DOUBLE_ASSIGNMENT (ld, num); - rhs = ACE_CDR::Fixed::from_floating (ld); - return lhs; -} -#endif - -bool ACE_CDR::Fixed::less (const ACE_CDR::Fixed &rhs) const -{ - const Fixed &lhs = *this; - if (lhs.sign () != rhs.sign ()) - return lhs.sign (); - - // signs of lhs and rhs are the same so lhs < rhs reduces to: - // if positive, |lhs| < |rhs| - // if negative, |rhs| < |lhs| - // 'a' will refer to the value left of < and 'b' to the value to the right - const ACE_CDR::Fixed &a = lhs.sign () ? rhs : lhs, - &b = lhs.sign () ? lhs : rhs; - - if (a.scale_ == b.scale_) - return ACE_OS::memcmp (a.value_, b.value_, sizeof a.value_) < 0; - - const int a_int_dig = a.digits_ - a.scale_, b_int_dig = b.digits_ - b.scale_; - - if (a_int_dig > b_int_dig) - { - for (int i = 1; i <= a_int_dig - b_int_dig; ++i) - if (a.digit (a.digits_ - i)) - return false; - } - else if (a_int_dig < b_int_dig) - { - for (int i = 1; i <= b_int_dig - a_int_dig; ++i) - if (b.digit (b.digits_ - i)) - return true; - } - - const int common_frac = (std::min) (a.scale_, b.scale_), - common_dig = (std::min) (a_int_dig, b_int_dig) + common_frac, - a_off = a.scale_ - common_frac, // a's offset (more scale than b) - b_off = b.scale_ - common_frac; // b's offset (more scale than a) - - for (int i = 1; i <= common_dig; ++i) - if (a.digit (a_off + common_dig - i) < b.digit (b_off + common_dig - i)) - return true; - - for (int i = 1; i <= a_off; ++i) - if (a.digit (a_off - i)) - return false; - - for (int i = 1; i <= b_off; ++i) - if (b.digit (b_off - i)) - return true; - - return false; -} - -bool ACE_CDR::Fixed::equal (const ACE_CDR::Fixed &rhs) const -{ - const Fixed &lhs = *this; - if (lhs.sign () != rhs.sign ()) - return false; - - if (lhs.scale_ == rhs.scale_) - return 0 == ACE_OS::memcmp (lhs.value_, rhs.value_, sizeof lhs.value_); - - const ACE_CDR::Fixed &more = (lhs.scale_ > rhs.scale_) ? lhs : rhs, - &fewer = (lhs.scale_ > rhs.scale_) ? rhs : lhs; - - const ACE_CDR::Octet scale_diff = more.scale_ - fewer.scale_; - - ACE_CDR::Fixed::ConstIterator more_iter = more.begin (), - more_end = more.end (); - - for (ACE_CDR::Octet i = 0; i < scale_diff; ++i) - if (more_iter == more_end || *more_iter++) - return false; // digits in more that are missing in fewer must be 0 - - ACE_CDR::Fixed::ConstIterator fewer_iter = fewer.begin (), - fewer_end = fewer.end (); - - while (more_iter != more_end && fewer_iter != fewer_end) - if (*more_iter++ != *fewer_iter++) - return false; // digits in common must match - - while (more_iter != more_end) - if (*more_iter++) - return false; // extra (more significant) digits in more must be 0 - - while (fewer_iter != fewer_end) - if (*fewer_iter++) - return false; // extra (more significant) digits in fewer must be 0 - - return true; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/CDR_Base.h b/deps/acelite/ace/CDR_Base.h deleted file mode 100644 index a8b49e5a0..000000000 --- a/deps/acelite/ace/CDR_Base.h +++ /dev/null @@ -1,535 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file CDR_Base.h - * - * ACE Common Data Representation (CDR) basic types. - * - * The current implementation assumes that the host has 1-byte, - * 2-byte and 4-byte integral types, and that it has single - * precision and double precision IEEE floats. - * Those assumptions are pretty good these days, with Crays being - * the only known exception. - * - * @author TAO version by - * @author Aniruddha Gokhale - * @author Carlos O'Ryan - * @author ACE version by - * @author Jeff Parsons - * @author Istvan Buki - */ -//============================================================================= - -#ifndef ACE_CDR_BASE_H -#define ACE_CDR_BASE_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Basic_Types.h" -#include "ace/Default_Constants.h" -#include "ace/Global_Macros.h" -#include "ace/iosfwd.h" - -#include - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Stuff used by the ACE CDR classes. Watch these values... they're also used -// in the ACE_CDR Byte_Order enum below. -#if defined ACE_LITTLE_ENDIAN -# define ACE_CDR_BYTE_ORDER 1 -// little endian encapsulation byte order has value = 1 -#else /* ! ACE_LITTLE_ENDIAN */ -# define ACE_CDR_BYTE_ORDER 0 -// big endian encapsulation byte order has value = 0 -#endif /* ! ACE_LITTLE_ENDIAN */ - -class ACE_Message_Block; - -/** - * @class ACE_CDR - * - * @brief Keep constants and some routines common to both Output and - * Input CDR streams. - */ -class ACE_Export ACE_CDR -{ -public: - // = Constants defined by the CDR protocol. - // By defining as many of these constants as possible as enums we - // ensure they get inlined and avoid pointless static memory - // allocations. - - enum - { - // Note that some of these get reused as part of the standard - // binary format: unsigned is the same size as its signed cousin, - // float is LONG_SIZE, and double is LONGLONG_SIZE. - - OCTET_SIZE = 1, - SHORT_SIZE = 2, - LONG_SIZE = 4, - LONGLONG_SIZE = 8, - LONGDOUBLE_SIZE = 16, - - OCTET_ALIGN = 1, - SHORT_ALIGN = 2, - LONG_ALIGN = 4, - LONGLONG_ALIGN = 8, - /// @note the CORBA LongDouble alignment requirements do not - /// match its size... - LONGDOUBLE_ALIGN = 8, - - /// Maximal CDR 1.1 alignment: "quad precision" FP (i.e. "CDR::Long - /// double", size as above). - MAX_ALIGNMENT = 8, - - /// The default buffer size. - /** - * @todo We want to add options to control this - * default value, so this constant should be read as the default - * default value ;-) - */ - DEFAULT_BUFSIZE = ACE_DEFAULT_CDR_BUFSIZE, - - /// The buffer size grows exponentially until it reaches this size; - /// afterwards it grows linearly using the next constant - EXP_GROWTH_MAX = ACE_DEFAULT_CDR_EXP_GROWTH_MAX, - - /// Once exponential growth is ruled out the buffer size increases - /// in chunks of this size, note that this constants have the same - /// value right now, but it does not need to be so. - LINEAR_GROWTH_CHUNK = ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK - }; - - /** - * @enum Byte_Order - * - * Defines values for the byte_order argument to ACE_OutputCDR and - * ACE_InputCDR. - */ - enum Byte_Order - { - /// Use big-endian order (also known as network byte order). - BYTE_ORDER_BIG_ENDIAN = 0, - /// Use little-endian order. - BYTE_ORDER_LITTLE_ENDIAN = 1, - /// Use whichever byte order is native to this machine. - BYTE_ORDER_NATIVE = ACE_CDR_BYTE_ORDER - }; - - /** - * Do byte swapping for each basic IDL type size. There exist only - * routines to put byte, halfword (2 bytes), word (4 bytes), - * doubleword (8 bytes) and quadword (16 byte); because those are - * the IDL basic type sizes. - */ - static void swap_2 (char const *orig, char *target); - static void swap_4 (char const *orig, char *target); - static void swap_8 (char const *orig, char *target); - static void swap_16 (char const *orig, char *target); - static void swap_2_array (char const *orig, - char *target, - size_t length); - static void swap_4_array (char const *orig, - char *target, - size_t length); - static void swap_8_array (char const *orig, - char *target, - size_t length); - static void swap_16_array (char const *orig, - char *target, - size_t length); - - /// Align the message block to ACE_CDR::MAX_ALIGNMENT, - /// set by the CORBA spec at 8 bytes. - static void mb_align (ACE_Message_Block *mb); - - /** - * Compute the size of the smallest buffer that can contain at least - * @a minsize bytes. - * To understand how a "best fit" is computed look at the - * algorithm in the code. - * Basically the buffers grow exponentially, up to a certain point, - * then the buffer size grows linearly. - * The advantage of this algorithm is that is rapidly grows to a - * large value, but does not explode at the end. - */ - static size_t first_size (size_t minsize); - - /// Compute not the smallest, but the second smallest buffer that - /// will fir @a minsize bytes. - static size_t next_size (size_t minsize); - - /** - * Increase the capacity of mb to contain at least @a minsize bytes. - * If @a minsize is zero the size is increased by an amount at least - * large enough to contain any of the basic IDL types. - * @retval -1 Failure - * @retval 0 Success. - */ - static int grow (ACE_Message_Block *mb, size_t minsize); - - /** - * Copy a message block chain into a single message block, - * preserving the alignment of the first message block of the - * original stream, not the following message blocks. - * @retval -1 Failure - * @retval 0 Success. - */ - static int consolidate (ACE_Message_Block *dst, - const ACE_Message_Block *src); - - static size_t total_length (const ACE_Message_Block *begin, - const ACE_Message_Block *end); - - /** - * @name Basic OMG IDL Types - * - * These types are for use in the CDR classes. The cleanest way to - * avoid complaints from all compilers is to define them all. - */ - //@{ - typedef bool Boolean; - typedef unsigned char Octet; - typedef char Char; - typedef ACE_WCHAR_T WChar; - typedef ACE_INT16 Short; - typedef ACE_UINT16 UShort; - typedef ACE_INT32 Long; - typedef ACE_UINT32 ULong; - typedef ACE_INT64 LongLong; - typedef ACE_UINT64 ULongLong; - -# if ACE_SIZEOF_FLOAT == 4 - typedef float Float; -# else /* ACE_SIZEOF_FLOAT != 4 */ - struct Float - { -# if ACE_SIZEOF_INT == 4 - // Use unsigned int to get word alignment. - unsigned int f; -# else /* ACE_SIZEOF_INT != 4 */ - // Applications will probably have trouble with this. - char f[4]; -# endif /* ACE_SIZEOF_INT != 4 */ - }; -# endif /* ACE_SIZEOF_FLOAT != 4 */ - -# if ACE_SIZEOF_DOUBLE == 8 - typedef double Double; -# else /* ACE_SIZEOF_DOUBLE != 8 */ - struct Double - { -# if ACE_SIZEOF_LONG == 8 - // Use u long to get word alignment. - unsigned long f; -# else /* ACE_SIZEOF_INT != 8 */ - // Applications will probably have trouble with this. - char f[8]; -# endif /* ACE_SIZEOF_INT != 8 */ - }; -# endif /* ACE_SIZEOF_DOUBLE != 8 */ - - // 94-9-32 Appendix A defines a 128 bit floating point "long - // double" data type, with greatly extended precision and four - // more bits of exponent (compared to "double"). This is an IDL - // extension, not yet standard. - -# if ACE_SIZEOF_LONG_DOUBLE == 16 - typedef long double LongDouble; -# define ACE_CDR_LONG_DOUBLE_INITIALIZER 0 -# define ACE_CDR_LONG_DOUBLE_ASSIGNMENT(LHS, RHS) LHS = RHS -# else -# define NONNATIVE_LONGDOUBLE -# define ACE_CDR_LONG_DOUBLE_INITIALIZER {{0}} -# define ACE_CDR_LONG_DOUBLE_ASSIGNMENT(LHS, RHS) LHS.assign (RHS) - struct ACE_Export LongDouble - { - // VxWorks' compiler (gcc 2.96) gets confused by the operator long - // double, so we avoid using long double as the NativeImpl. - // Linux's x86 long double format (12 or 16 bytes) is incompatible - // with Windows, Solaris, AIX, MacOS X and HP-UX (and probably others) - // long double format (8 or 16 bytes). If you need 32-bit Linux to - // inter-operate with 64-bit Linux you will want to define this - // macro to 0 so that "long double" is used. Otherwise, do not define - // this macro. -# if defined (ACE_CDR_IMPLEMENT_WITH_NATIVE_DOUBLE) && \ - (ACE_CDR_IMPLEMENT_WITH_NATIVE_DOUBLE == 1) - typedef double NativeImpl; -# else - typedef long double NativeImpl; -# endif /* ACE_CDR_IMPLEMENT_WITH_NATIVE_DOUBLE==1 */ - - char ld[16]; - - LongDouble& assign (const NativeImpl& rhs); - LongDouble& assign (const LongDouble& rhs); - - bool operator== (const LongDouble &rhs) const; - bool operator!= (const LongDouble &rhs) const; - - LongDouble& operator*= (const NativeImpl rhs) { - return this->assign (static_cast (*this) * rhs); - } - LongDouble& operator/= (const NativeImpl rhs) { - return this->assign (static_cast (*this) / rhs); - } - LongDouble& operator+= (const NativeImpl rhs) { - return this->assign (static_cast (*this) + rhs); - } - LongDouble& operator-= (const NativeImpl rhs) { - return this->assign (static_cast (*this) - rhs); - } - LongDouble& operator++ () { - return this->assign (static_cast (*this) + 1); - } - LongDouble& operator-- () { - return this->assign (static_cast (*this) - 1); - } - LongDouble operator++ (int) { - LongDouble ldv = *this; - this->assign (static_cast (*this) + 1); - return ldv; - } - LongDouble operator-- (int) { - LongDouble ldv = *this; - this->assign (static_cast (*this) - 1); - return ldv; - } - - operator NativeImpl () const; - }; -# endif /* ACE_SIZEOF_LONG_DOUBLE != 16 */ - -#define ACE_HAS_CDR_FIXED - /// Fixed-point data type: up to 31 decimal digits and a sign bit - /// - /// See OMG 2011-11-01 CORBA Interfaces v3.2 sections 7.10, 7.11.3.4 - /// See OMG 2011-11-02 CORBA Interoperability v3.2 section 9.3.2.8 - /// See OMG 2012-07-02 IDL-to-C++ Mapping v1.3 section 5.13 - /// This class doesn't exactly match the IDL-to-C++ mapping because - /// it is meant for use inside a union in the IDL compiler and therefore - /// has no constructors. Standards-based middleware libraries such as - /// ORBs and DDSs can wrap this class in a class of their own to provide - /// the exact interface described by the mapping specification. - class ACE_Export Fixed - { - public: - enum - { - MAX_DIGITS = 31, - MAX_STRING_SIZE = 4 + MAX_DIGITS, // includes -, 0, ., terminator - POSITIVE = 0xc, - NEGATIVE = 0xd - }; - - static Fixed from_integer (LongLong val = 0); - static Fixed from_integer (ULongLong val); - static Fixed from_floating (LongDouble val); - static Fixed from_string (const char *str); - static Fixed from_octets (const Octet *array, int len, - unsigned int scale = 0); - - operator LongLong () const; - operator LongDouble () const; - - Fixed round (UShort scale) const; - Fixed truncate (UShort scale) const; - - bool to_string (char *buffer, size_t buffer_size) const; - const Octet *to_octets (int &n) const; - - Fixed &operator+= (const Fixed &rhs); - Fixed &operator-= (const Fixed &rhs); - Fixed &operator*= (const Fixed &rhs); - Fixed &operator/= (const Fixed &rhs); - - Fixed &operator++ (); - Fixed operator++ (int); - Fixed &operator-- (); - Fixed operator-- (int); - - Fixed operator+ () const; - Fixed operator- () const; - bool operator! () const; - - UShort fixed_digits () const; - UShort fixed_scale () const; - - bool sign () const; - Octet digit (int n) const; - void digit (int n, int value); - - bool less (const Fixed &rhs) const; - bool equal (const Fixed &rhs) const; - - class Proxy - { - bool high_nibble_; - Octet &element_; - public: - Proxy (bool high_nibble, Octet &element); - Proxy &operator= (Octet val); - Proxy &operator+= (int rhs); - Proxy &operator-= (int rhs); - Proxy &operator++ (); - Proxy &operator-- (); - operator Octet () const; - }; - - class IteratorBase - { - protected: - explicit IteratorBase (int digit); - bool high_nibble () const; - Octet &storage (Fixed *outer) const; - Octet storage (const Fixed *outer) const; - bool compare (const IteratorBase &rhs) const; - int digit_; - }; - - class Iterator - : public std::iterator - , private IteratorBase - { - public: - explicit Iterator (Fixed *outer, int digit = 0); - Proxy operator* (); - Iterator &operator+= (std::ptrdiff_t n); - Iterator &operator++ (); - Iterator operator++ (int); - Iterator &operator-- (); - Iterator operator-- (int); - bool operator== (const Iterator &rhs) const; - bool operator!= (const Iterator &rhs) const; - private: - Fixed *outer_; - }; - - class ConstIterator - : public std::iterator - , private IteratorBase - { - public: - explicit ConstIterator (const Fixed *outer, int digit = 0); - Octet operator* (); - ConstIterator &operator+= (std::ptrdiff_t n); - ConstIterator &operator++ (); - ConstIterator operator++ (int); - ConstIterator &operator-- (); - ConstIterator operator-- (int); - bool operator== (const ConstIterator &rhs) const; - bool operator!= (const ConstIterator &rhs) const; - private: - const Fixed *outer_; - }; - - Iterator begin (); - ConstIterator begin () const; - ConstIterator cbegin () const; - Iterator end (); - ConstIterator end () const; - ConstIterator cend () const; - - private: - /// CDR wire format for Fixed: marshaled as an octet array with - /// index 0 as the most significant octet and index n the least - /// significant. Each octet contains two decimal digits except for - /// the last octet (least sig) which has one decimal digit in - /// the high nibble and the sign indicator in the low nibble. - Octet value_[16]; - - /// digits_ is not marshaled, the receiver needs to know it - /// from the type information (for example, IDL). The value of - /// digits_ determines how many octets of value_ are masharled. - Octet digits_; - - /// scale_ is not marshaled, the receiver needs to know it - /// from the type information (for example, IDL). - Octet scale_; - - /// remove trailing zeros, shift down and reduce digits and scale - void normalize (UShort min_scale = 0); - - /// Add up to 'digits' of additional scale by shifting left without - /// removing significant digits. Returns number of digits shifted. - int lshift (int digits); - - /// Prepare to add (or subtract) f by changing the digits and scale - /// of *this, returnins an iterator to the least significant - /// digit of f that will influence the sum (or difference). - ConstIterator pre_add (const Fixed &f); - - Fixed div_helper2 (const Fixed &rhs, Fixed &r) const; - Fixed div_helper1 (const Fixed &rhs, Fixed &r) const; - Fixed join (int digits, const Fixed &bottom) const; - void ltrim (); - }; - - //@} - -#if !defined (ACE_CDR_GIOP_MAJOR_VERSION) -# define ACE_CDR_GIOP_MAJOR_VERSION 1 -#endif /*ACE_CDR_GIOP_MAJOR_VERSION */ - -#if !defined (ACE_CDR_GIOP_MINOR_VERSION) -# define ACE_CDR_GIOP_MINOR_VERSION 2 -#endif /* ACE_CDR_GIOP_MINOR_VERSION */ -}; - -ACE_Export -ACE_OSTREAM_TYPE &operator<< (ACE_OSTREAM_TYPE &lhs, const ACE_CDR::Fixed &rhs); - -#ifndef ACE_LACKS_IOSTREAM_TOTALLY -ACE_Export -std::istream &operator>> (std::istream &lhs, ACE_CDR::Fixed &rhs); -#endif - -ACE_Export -bool operator< (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs); - -ACE_Export -bool operator> (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs); - -ACE_Export -bool operator>= (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs); - -ACE_Export -bool operator<= (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs); - -ACE_Export -bool operator== (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs); - -ACE_Export -bool operator!= (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs); - -ACE_Export -ACE_CDR::Fixed operator+ (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs); - -ACE_Export -ACE_CDR::Fixed operator- (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs); - -ACE_Export -ACE_CDR::Fixed operator* (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs); - -ACE_Export -ACE_CDR::Fixed operator/ (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs); - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -# include "ace/CDR_Base.inl" -#endif /* __ACE_INLINE__ */ - - -#include /**/ "ace/post.h" - -#endif /* ACE_CDR_BASE_H */ diff --git a/deps/acelite/ace/CDR_Base.inl b/deps/acelite/ace/CDR_Base.inl deleted file mode 100644 index c31c3b785..000000000 --- a/deps/acelite/ace/CDR_Base.inl +++ /dev/null @@ -1,629 +0,0 @@ -// -*- C++ -*- -#if defined (ACE_HAS_INTRINSIC_BYTESWAP) -// Take advantage of MSVC++ byte swapping compiler intrinsics (found -// in ). -# pragma intrinsic (_byteswap_ushort, _byteswap_ulong, _byteswap_uint64) -#endif /* ACE_HAS_INTRINSIC_BYTESWAP */ - -#if defined (ACE_HAS_BSWAP_16) || defined (ACE_HAS_BSWAP_32) || defined (ACE_HAS_BSWAP_64) -# include "ace/os_include/os_byteswap.h" -#endif - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// -// The ACE_CDR::swap_X and ACE_CDR::swap_X_array routines are broken -// in 5 cases for optimization: -// -// * MSVC++ 7.1 or better -// => Compiler intrinsics -// -// * AMD64 CPU + gnu g++ -// => gcc amd64 inline assembly. -// -// * x86 Pentium CPU + gnu g++ -// (ACE_HAS_PENTIUM && __GNUG__) -// => gcc x86 inline assembly. -// -// * x86 Pentium CPU and (_MSC_VER) or BORLAND C++) -// (ACE_HAS_PENTIUM && ( _MSC_VER || __BORLANDC__ ) -// => MSC x86 inline assembly. -// -// * 64 bit architecture -// (ACE_SIZEOF_LONG == 8) -// => shift/masks using 64bit words. -// -// * default -// (none of the above) -// => shift/masks using 32bit words. -// -// Some things you could find useful to know if you intend to mess -// with this optimizations for swaps: -// -// * MSVC++ don't assume register values are conserved between -// statements. So you can clobber any register you want, -// whenever you want (well not *anyone* really, see manual). -// The MSVC++ optimizer will try to pick different registers -// for the C++ statements sorrounding your asm block, and if -// it's not possible will use the stack. -// -// * If you clobber registers with asm statements in gcc, you -// better do it in an asm-only function, or save/restore them -// before/after in the stack. If not, sorrounding C statements -// could end using the same registers and big-badda-bum (been -// there, done that...). The big-badda-bum could happen *even -// if you specify the clobbered register in your asm's*. -// Even better, use gcc asm syntax for detecting the register -// asigned to a certain variable so you don't have to clobber any -// register directly. -// - -ACE_INLINE void -ACE_CDR::swap_2 (const char *orig, char* target) -{ -#if defined (ACE_HAS_INTRINSIC_BYTESWAP) - // Take advantage of MSVC++ compiler intrinsic byte swapping - // function. - *reinterpret_cast (target) = - _byteswap_ushort (*reinterpret_cast (orig)); -#elif defined (ACE_HAS_BUILTIN_BSWAP16) - *reinterpret_cast (target) = - __builtin_bswap16 (*reinterpret_cast (orig)); -#elif defined (ACE_HAS_BSWAP16) - *reinterpret_cast (target) = - bswap16 (*reinterpret_cast (orig)); -#elif defined (ACE_HAS_BSWAP_16) - *reinterpret_cast (target) = - bswap_16 (*reinterpret_cast (orig)); -#elif defined(ACE_HAS_INTEL_ASSEMBLY) - unsigned short a = - *reinterpret_cast (orig); - asm( "rolw $8, %0" : "=r" (a) : "0" (a) ); - *reinterpret_cast (target) = a; -#elif defined (ACE_HAS_PENTIUM) \ - && (defined(_MSC_VER) || defined(__BORLANDC__)) \ - && !defined(ACE_LACKS_INLINE_ASSEMBLY) - __asm mov ebx, orig; - __asm mov ecx, target; - __asm mov ax, [ebx]; - __asm rol ax, 8; - __asm mov [ecx], ax; -#else - ACE_UINT16 usrc = * reinterpret_cast (orig); - ACE_UINT16* udst = reinterpret_cast (target); - *udst = (usrc << 8) | (usrc >> 8); -#endif /* ACE_HAS_PENTIUM */ -} - -ACE_INLINE void -ACE_CDR::swap_4 (const char* orig, char* target) -{ -#if defined (ACE_HAS_INTRINSIC_BYTESWAP) - // Take advantage of MSVC++ compiler intrinsic byte swapping - // function. - *reinterpret_cast (target) = - _byteswap_ulong (*reinterpret_cast (orig)); -#elif defined (ACE_HAS_BUILTIN_BSWAP32) - *reinterpret_cast (target) = - __builtin_bswap32 (*reinterpret_cast (orig)); -#elif defined (ACE_HAS_BSWAP32) - *reinterpret_cast (target) = - bswap32 (*reinterpret_cast (orig)); -#elif defined (ACE_HAS_BSWAP_32) - *reinterpret_cast (target) = - bswap_32 (*reinterpret_cast (orig)); -#elif defined(ACE_HAS_INTEL_ASSEMBLY) - // We have ACE_HAS_PENTIUM, so we know the sizeof's. - unsigned int j = - *reinterpret_cast (orig); - asm ("bswap %1" : "=r" (j) : "0" (j)); - *reinterpret_cast (target) = j; -#elif defined(ACE_HAS_PENTIUM) \ - && (defined(_MSC_VER) || defined(__BORLANDC__)) \ - && !defined(ACE_LACKS_INLINE_ASSEMBLY) - __asm mov ebx, orig; - __asm mov ecx, target; - __asm mov eax, [ebx]; - __asm bswap eax; - __asm mov [ecx], eax; -#else - ACE_UINT32 x = * reinterpret_cast (orig); - x = (x << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | (x >> 24); - * reinterpret_cast (target) = x; -#endif /* ACE_HAS_INTRINSIC_BYTESWAP */ -} - -ACE_INLINE void -ACE_CDR::swap_8 (const char* orig, char* target) -{ -#if defined (ACE_HAS_INTRINSIC_BYTESWAP) - // Take advantage of MSVC++ compiler intrinsic byte swapping - // function. - *reinterpret_cast (target) = - _byteswap_uint64 (*reinterpret_cast (orig)); -#elif defined (ACE_HAS_BUILTIN_BSWAP64) - *reinterpret_cast (target) = - __builtin_bswap64 (*reinterpret_cast (orig)); -#elif defined (ACE_HAS_BSWAP64) - *reinterpret_cast (target) = - bswap64 (*reinterpret_cast (orig)); -#elif defined (ACE_HAS_BSWAP_64) - *reinterpret_cast (target) = - bswap_64 (*reinterpret_cast (orig)); -#elif (defined (__amd64__) || defined (__x86_64__)) && defined(__GNUG__) \ - && !defined(ACE_LACKS_INLINE_ASSEMBLY) - unsigned long x = - * reinterpret_cast (orig); - asm ("bswapq %1" : "=r" (x) : "0" (x)); - *reinterpret_cast (target) = x; -#elif defined(ACE_HAS_PENTIUM) && defined(__GNUG__) \ - && !defined(ACE_LACKS_INLINE_ASSEMBLY) - unsigned int i =*reinterpret_cast (orig); - unsigned int j = *reinterpret_cast (orig + 4); - asm ("bswap %1" : "=r" (i) : "0" (i)); - asm ("bswap %1" : "=r" (j) : "0" (j)); - *reinterpret_cast (target + 4) = i; - *reinterpret_cast (target) = j; -#elif defined(ACE_HAS_PENTIUM) \ - && (defined(_MSC_VER) || defined(__BORLANDC__)) \ - && !defined(ACE_LACKS_INLINE_ASSEMBLY) - __asm mov ecx, orig; - __asm mov edx, target; - __asm mov eax, [ecx]; - __asm mov ebx, 4[ecx]; - __asm bswap eax; - __asm bswap ebx; - __asm mov 4[edx], eax; - __asm mov [edx], ebx; -#elif ACE_SIZEOF_LONG == 8 - // 64 bit architecture. - unsigned long x = * reinterpret_cast (orig); - unsigned long x84 = (x & 0x000000ff000000ffUL) << 24; - unsigned long x73 = (x & 0x0000ff000000ff00UL) << 8; - unsigned long x62 = (x & 0x00ff000000ff0000UL) >> 8; - unsigned long x51 = (x & 0xff000000ff000000UL) >> 24; - x = (x84 | x73 | x62 | x51); - x = (x << 32) | (x >> 32); - *reinterpret_cast (target) = x; -#else - ACE_UINT32 x = * reinterpret_cast (orig); - ACE_UINT32 y = * reinterpret_cast (orig + 4); - x = (x << 24) | ((x & 0xff00) << 8) | ((x & 0xff0000) >> 8) | (x >> 24); - y = (y << 24) | ((y & 0xff00) << 8) | ((y & 0xff0000) >> 8) | (y >> 24); - * reinterpret_cast (target) = y; - * reinterpret_cast (target + 4) = x; -#endif /* ACE_HAS_INTRINSIC_BYTESWAP */ -} - -ACE_INLINE void -ACE_CDR::swap_16 (const char* orig, char* target) -{ - swap_8 (orig + 8, target); - swap_8 (orig, target + 8); -} - -ACE_INLINE size_t -ACE_CDR::first_size (size_t minsize) -{ - if (minsize == 0) - return ACE_CDR::DEFAULT_BUFSIZE; - - size_t newsize = ACE_CDR::DEFAULT_BUFSIZE; - while (newsize < minsize) - { - if (newsize < ACE_CDR::EXP_GROWTH_MAX) - { - // We grow exponentially at the beginning, this is fast and - // reduces the number of allocations. - - // Quickly multiply by two using a bit shift. This is - // guaranteed to work since the variable is an unsigned - // integer. - newsize <<= 1; - } - else - { - // but continuing with exponential growth can result in over - // allocations and easily yield an allocation failure. - // So we grow linearly when the buffer is too big. - newsize += ACE_CDR::LINEAR_GROWTH_CHUNK; - } - } - return newsize; -} - -ACE_INLINE size_t -ACE_CDR::next_size (size_t minsize) -{ - size_t newsize = ACE_CDR::first_size (minsize); - - if (newsize == minsize) - { - // If necessary increment the size - if (newsize < ACE_CDR::EXP_GROWTH_MAX) - // Quickly multiply by two using a bit shift. This is - // guaranteed to work since the variable is an unsigned - // integer. - newsize <<= 1; - else - newsize += ACE_CDR::LINEAR_GROWTH_CHUNK; - } - - return newsize; -} - -ACE_INLINE ACE_CDR::UShort -ACE_CDR::Fixed::fixed_digits () const -{ - return this->digits_; -} - -ACE_INLINE ACE_CDR::UShort -ACE_CDR::Fixed::fixed_scale () const -{ - return this->scale_; -} - -ACE_INLINE bool -ACE_CDR::Fixed::sign () const -{ - return (this->value_[15] & 0xf) == NEGATIVE; -} - -ACE_INLINE ACE_CDR::Octet -ACE_CDR::Fixed::digit (int n) const -{ - const Octet x = this->value_[15 - (n + 1) / 2]; - return (n % 2) ? x & 0xf : (x >> 4); -} - -ACE_INLINE void -ACE_CDR::Fixed::digit (int n, int val) -{ - const int idx = 15 - (n + 1) / 2; - this->value_[idx] = (n % 2) ? (this->value_[idx] & 0xf0) | val - : ((val << 4) | (this->value_[idx] & 0xf)); -} - -ACE_INLINE -ACE_CDR::Fixed::Proxy::Proxy (bool high_nibble, Octet &element) - : high_nibble_ (high_nibble), element_ (element) {} - -ACE_INLINE ACE_CDR::Fixed::Proxy & -ACE_CDR::Fixed::Proxy::operator= (Octet val) -{ - this->element_ = this->high_nibble_ - ? (val << 4) | (this->element_ & 0xf) - : ((this->element_ & 0xf0) | val); - return *this; -} - -ACE_INLINE ACE_CDR::Fixed::Proxy & -ACE_CDR::Fixed::Proxy::operator+= (int rhs) -{ - const Octet val = static_cast (*this + rhs); - return *this = val; -} - -ACE_INLINE ACE_CDR::Fixed::Proxy & -ACE_CDR::Fixed::Proxy::operator-= (int rhs) -{ - const Octet val = static_cast (*this - rhs); - return *this = val; -} - -ACE_INLINE ACE_CDR::Fixed::Proxy & -ACE_CDR::Fixed::Proxy::operator++ () -{ - const Octet val = static_cast (*this) + 1; - return *this = val; -} - -ACE_INLINE ACE_CDR::Fixed::Proxy & -ACE_CDR::Fixed::Proxy::operator-- () -{ - const Octet val = static_cast(*this) - 1; - return *this = val; -} - -ACE_INLINE -ACE_CDR::Fixed::Proxy::operator ACE_CDR::Octet () const -{ - return this->high_nibble_ ? this->element_ >> 4 : (this->element_ & 0xf); -} - -ACE_INLINE -ACE_CDR::Fixed::IteratorBase::IteratorBase (int digit) - : digit_ (digit) {} - -ACE_INLINE bool -ACE_CDR::Fixed::IteratorBase::high_nibble () const -{ - return this->digit_ % 2 == 0; -} - -ACE_INLINE ACE_CDR::Octet & -ACE_CDR::Fixed::IteratorBase::storage (Fixed *outer) const -{ - return outer->value_[15 - (this->digit_ + 1) / 2]; -} - -ACE_INLINE ACE_CDR::Octet -ACE_CDR::Fixed::IteratorBase::storage (const Fixed *outer) const -{ - return outer->value_[15 - (this->digit_ + 1) / 2]; -} - -ACE_INLINE bool -ACE_CDR::Fixed::IteratorBase::compare (const IteratorBase &rhs) const -{ - return this->digit_ == rhs.digit_; -} - -ACE_INLINE -ACE_CDR::Fixed::Iterator::Iterator (Fixed *outer, int digit) - : IteratorBase (digit), outer_ (outer) {} - -ACE_INLINE ACE_CDR::Fixed::Proxy -ACE_CDR::Fixed::Iterator::operator* () -{ - return Proxy (this->high_nibble (), this->storage (this->outer_)); -} - -ACE_INLINE ACE_CDR::Fixed::Iterator & -ACE_CDR::Fixed::Iterator::operator+= (std::ptrdiff_t n) -{ - this->digit_ += static_cast (n); - return *this; -} - -ACE_INLINE ACE_CDR::Fixed::Iterator & -ACE_CDR::Fixed::Iterator::operator++ () -{ - ++this->digit_; - return *this; -} - -ACE_INLINE ACE_CDR::Fixed::Iterator -ACE_CDR::Fixed::Iterator::operator++ (int) -{ - const Iterator cpy (*this); - ++this->digit_; - return cpy; -} - -ACE_INLINE ACE_CDR::Fixed::Iterator & -ACE_CDR::Fixed::Iterator::operator-- () -{ - --this->digit_; - return *this; -} - -ACE_INLINE ACE_CDR::Fixed::Iterator -ACE_CDR::Fixed::Iterator::operator-- (int) -{ - const Iterator cpy (*this); - --this->digit_; - return cpy; -} - -ACE_INLINE bool -ACE_CDR::Fixed::Iterator::operator== (const Iterator &rhs) const -{ - return this->compare (rhs); -} - -ACE_INLINE bool -ACE_CDR::Fixed::Iterator::operator!= (const Iterator &rhs) const -{ - return !(*this == rhs); -} - -ACE_INLINE -ACE_CDR::Fixed::ConstIterator::ConstIterator (const Fixed *outer, int digit) - : IteratorBase (digit), outer_ (outer) {} - -ACE_INLINE ACE_CDR::Octet -ACE_CDR::Fixed::ConstIterator::operator* () -{ - const Octet storage = this->storage (this->outer_); - return this->high_nibble () ? storage >> 4 : (storage & 0xf); -} - -ACE_INLINE ACE_CDR::Fixed::ConstIterator & -ACE_CDR::Fixed::ConstIterator::operator+= (std::ptrdiff_t n) -{ - this->digit_ += static_cast (n); - return *this; -} - -ACE_INLINE ACE_CDR::Fixed::ConstIterator & -ACE_CDR::Fixed::ConstIterator::operator++ () -{ - ++this->digit_; - return *this; -} - -ACE_INLINE ACE_CDR::Fixed::ConstIterator -ACE_CDR::Fixed::ConstIterator::operator++ (int) -{ - const ConstIterator cpy (*this); - ++this->digit_; - return cpy; -} - -ACE_INLINE ACE_CDR::Fixed::ConstIterator & -ACE_CDR::Fixed::ConstIterator::operator-- () -{ - --this->digit_; - return *this; -} - -ACE_INLINE ACE_CDR::Fixed::ConstIterator -ACE_CDR::Fixed::ConstIterator::operator-- (int) -{ - const ConstIterator cpy (*this); - --this->digit_; - return cpy; -} - -ACE_INLINE bool -ACE_CDR::Fixed::ConstIterator::operator== (const ConstIterator &rhs) const -{ - return this->compare (rhs); -} - -ACE_INLINE bool -ACE_CDR::Fixed::ConstIterator::operator!= (const ConstIterator &rhs) const -{ - return !(*this == rhs); -} - -ACE_INLINE ACE_CDR::Fixed::Iterator -ACE_CDR::Fixed::begin () -{ - return Iterator (this); -} - -ACE_INLINE ACE_CDR::Fixed::ConstIterator -ACE_CDR::Fixed::begin () const -{ - return ConstIterator (this); -} - -ACE_INLINE ACE_CDR::Fixed::ConstIterator -ACE_CDR::Fixed::cbegin () const -{ - return ConstIterator (this); -} - -ACE_INLINE ACE_CDR::Fixed::Iterator -ACE_CDR::Fixed::end () -{ - return Iterator (this, this->digits_); -} - -ACE_INLINE ACE_CDR::Fixed::ConstIterator -ACE_CDR::Fixed::end () const -{ - return ConstIterator (this, this->digits_); -} - -ACE_INLINE ACE_CDR::Fixed::ConstIterator -ACE_CDR::Fixed::cend () const -{ - return ConstIterator (this, this->digits_); -} - -ACE_INLINE ACE_CDR::Fixed -ACE_CDR::Fixed::operator++ (int) -{ - const Fixed cpy (*this); - ++*this; - return cpy; -} - -ACE_INLINE ACE_CDR::Fixed -ACE_CDR::Fixed::operator-- (int) -{ - const Fixed cpy (*this); - --*this; - return cpy; -} - -ACE_INLINE ACE_CDR::Fixed -ACE_CDR::Fixed::operator+ () const -{ - return *this; -} - -ACE_INLINE ACE_CDR::Fixed -ACE_CDR::Fixed::operator- () const -{ - Fixed f = *this; - f.value_[15] = (f.value_[15] & 0xf0) | (f.sign () ? POSITIVE : NEGATIVE); - return f; -} - -ACE_INLINE void -ACE_CDR::Fixed::ltrim () -{ - for (int i = this->digits_ - 1; i >= this->scale_ && i > 0; --i) - if (this->digit (i) == 0) - --this->digits_; - else - break; -} - -ACE_INLINE ACE_CDR::Fixed -operator+ (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs) -{ - ACE_CDR::Fixed f = lhs; - f += rhs; - return f; -} - -ACE_INLINE ACE_CDR::Fixed -operator- (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs) -{ - ACE_CDR::Fixed f = lhs; - f -= rhs; - return f; -} - -ACE_INLINE ACE_CDR::Fixed -operator* (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs) -{ - ACE_CDR::Fixed f = lhs; - f *= rhs; - return f; -} - -ACE_INLINE ACE_CDR::Fixed -operator/ (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs) -{ - ACE_CDR::Fixed f = lhs; - f /= rhs; - return f; -} - -ACE_INLINE bool -operator< (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs) -{ - return lhs.less (rhs); -} - -ACE_INLINE bool -operator> (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs) -{ - return rhs < lhs; -} - -ACE_INLINE bool -operator>= (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs) -{ - return !(lhs < rhs); -} - -ACE_INLINE bool -operator<= (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs) -{ - return !(rhs < lhs); -} - -ACE_INLINE bool -operator== (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs) -{ - return lhs.equal (rhs); -} - -ACE_INLINE bool -operator!= (const ACE_CDR::Fixed &lhs, const ACE_CDR::Fixed &rhs) -{ - return !(lhs == rhs); -} - - -ACE_END_VERSIONED_NAMESPACE_DECL - -// **************************************************************** diff --git a/deps/acelite/ace/CDR_Size.cpp b/deps/acelite/ace/CDR_Size.cpp deleted file mode 100644 index 4263532eb..000000000 --- a/deps/acelite/ace/CDR_Size.cpp +++ /dev/null @@ -1,258 +0,0 @@ -#include "ace/CDR_Size.h" -#include "ace/SString.h" -#include "ace/OS_Memory.h" -#include "ace/Truncate.h" - -#if !defined (__ACE_INLINE__) -# include "ace/CDR_Size.inl" -#endif /* ! __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_CDR::Boolean -ACE_SizeCDR::write_wchar (ACE_CDR::WChar x) -{ - // Note: translator framework is not supported. - // - if (ACE_OutputCDR::wchar_maxbytes () == 0) - { - errno = EACCES; - return (this->good_bit_ = false); - } - - if (static_cast (major_version_) == 1 - && static_cast (minor_version_) == 2) - { - ACE_CDR::Octet len = - static_cast (ACE_OutputCDR::wchar_maxbytes ()); - - if (this->write_1 (&len)) - { - if (ACE_OutputCDR::wchar_maxbytes () == sizeof(ACE_CDR::WChar)) - { - return - this->write_octet_array ( - reinterpret_cast (&x), - static_cast (len)); - } - else - { - if (ACE_OutputCDR::wchar_maxbytes () == 2) - { - ACE_CDR::Short sx = static_cast (x); - return - this->write_octet_array ( - reinterpret_cast (&sx), - static_cast (len)); - } - else - { - ACE_CDR::Octet ox = static_cast (x); - return - this->write_octet_array ( - reinterpret_cast (&ox), - static_cast (len)); - } - } - } - } - else if (static_cast (minor_version_) == 0) - { // wchar is not allowed with GIOP 1.0. - errno = EINVAL; - return (this->good_bit_ = false); - } - - if (ACE_OutputCDR::wchar_maxbytes () == sizeof (ACE_CDR::WChar)) - { - const void *temp = &x; - return this->write_4 (reinterpret_cast (temp)); - } - else if (ACE_OutputCDR::wchar_maxbytes () == 2) - { - ACE_CDR::Short sx = static_cast (x); - return this->write_2 (reinterpret_cast (&sx)); - } - - ACE_CDR::Octet ox = static_cast (x); - return this->write_1 (reinterpret_cast (&ox)); -} - -ACE_CDR::Boolean -ACE_SizeCDR::write_string (ACE_CDR::ULong len, - const ACE_CDR::Char *x) -{ - // Note: translator framework is not supported. - // - if (len != 0) - { - if (this->write_ulong (len + 1)) - return this->write_char_array (x, len + 1); - } - else - { - // Be nice to programmers: treat nulls as empty strings not - // errors. (OMG-IDL supports languages that don't use the C/C++ - // notion of null v. empty strings; nulls aren't part of the OMG-IDL - // string model.) - if (this->write_ulong (1)) - return this->write_char (0); - } - - return (this->good_bit_ = false); -} - -ACE_CDR::Boolean -ACE_SizeCDR::write_string (const ACE_CString &x) -{ - // @@ Leave this method in here, not the `.i' file so that we don't - // have to unnecessarily pull in the `ace/SString.h' header. - return this->write_string (static_cast (x.length ()), - x.c_str()); -} - -ACE_CDR::Boolean -ACE_SizeCDR::write_wstring (ACE_CDR::ULong len, - const ACE_CDR::WChar *x) -{ - // Note: translator framework is not supported. - // - if (ACE_OutputCDR::wchar_maxbytes () == 0) - { - errno = EACCES; - return (this->good_bit_ = false); - } - - if (static_cast (this->major_version_) == 1 - && static_cast (this->minor_version_) == 2) - { - if (x != 0) - { - //In GIOP 1.2 the length field contains the number of bytes - //the wstring occupies rather than number of wchars - //Taking sizeof might not be a good way! This is a temporary fix. - ACE_CDR::Boolean good_ulong = - this->write_ulong ( - ACE_Utils::truncate_cast ( - ACE_OutputCDR::wchar_maxbytes () * len)); - - if (good_ulong) - { - return this->write_wchar_array (x, len); - } - } - else - { - //In GIOP 1.2 zero length wstrings are legal - return this->write_ulong (0); - } - } - - else - if (x != 0) - { - if (this->write_ulong (len + 1)) - return this->write_wchar_array (x, len + 1); - } - else if (this->write_ulong (1)) - return this->write_wchar (0); - return (this->good_bit_ = false); -} - -ACE_CDR::Boolean -ACE_SizeCDR::write_1 (const ACE_CDR::Octet *) -{ - this->adjust (1); - return true; -} - -ACE_CDR::Boolean -ACE_SizeCDR::write_2 (const ACE_CDR::UShort *) -{ - this->adjust (ACE_CDR::SHORT_SIZE); - return true; -} - -ACE_CDR::Boolean -ACE_SizeCDR::write_4 (const ACE_CDR::ULong *) -{ - this->adjust (ACE_CDR::LONG_SIZE); - return true; -} - -ACE_CDR::Boolean -ACE_SizeCDR::write_8 (const ACE_CDR::ULongLong *) -{ - this->adjust (ACE_CDR::LONGLONG_SIZE); - return true; -} - -ACE_CDR::Boolean -ACE_SizeCDR::write_16 (const ACE_CDR::LongDouble *) -{ - this->adjust (ACE_CDR::LONGDOUBLE_SIZE, - ACE_CDR::LONGDOUBLE_ALIGN); - return true; -} - -ACE_CDR::Boolean -ACE_SizeCDR::write_wchar_array_i (const ACE_CDR::WChar *, - ACE_CDR::ULong length) -{ - if (length == 0) - return true; - - size_t const align = (ACE_OutputCDR::wchar_maxbytes () == 2) ? - ACE_CDR::SHORT_ALIGN : - ACE_CDR::OCTET_ALIGN; - - this->adjust (ACE_OutputCDR::wchar_maxbytes () * length, align); - return true; -} - - -ACE_CDR::Boolean -ACE_SizeCDR::write_array (const void *, - size_t size, - size_t align, - ACE_CDR::ULong length) -{ - if (length == 0) - return true; - - this->adjust (size * length, align); - return true; -} - -ACE_CDR::Boolean -ACE_SizeCDR::write_boolean_array (const ACE_CDR::Boolean*, - ACE_CDR::ULong length) -{ - this->adjust (length, 1); - return true; -} - -void -ACE_SizeCDR::adjust (size_t size) -{ - adjust (size, size); -} - -void -ACE_SizeCDR::adjust (size_t size, - size_t align) -{ -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - const size_t offset = ACE_align_binary (size_, align) - size_; - size_ += offset; -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - size_ += size; -} - -ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, const ACE_CString &x) -{ - ss.write_string (x); - return ss.good_bit (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/CDR_Size.h b/deps/acelite/ace/CDR_Size.h deleted file mode 100644 index c535924f1..000000000 --- a/deps/acelite/ace/CDR_Size.h +++ /dev/null @@ -1,244 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file CDR_Size.h - * - * ACE Common Data Representation (CDR) size-calculating stream. - * - * The current implementation assumes that the host has 1-byte, - * 2-byte and 4-byte integral types, and that it has single - * precision and double precision IEEE floats. - * Those assumptions are pretty good these days, with Crays being - * the only known exception. - * - * @author Boris Kolpackov - */ -//============================================================================= - -#ifndef ACE_CDR_SIZE_H -#define ACE_CDR_SIZE_H - -#include /**/ "ace/pre.h" - -#include "ace/CDR_Base.h" -#include "ace/CDR_Stream.h" // for ACE_OutputCDR::from_* - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/SStringfwd.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_SizeCDR - * - * @brief A CDR stream for calculating size of the representation. - */ -class ACE_Export ACE_SizeCDR -{ -public: - /// Default constructor. - ACE_SizeCDR (ACE_CDR::Octet major_version = ACE_CDR_GIOP_MAJOR_VERSION, - ACE_CDR::Octet minor_version = ACE_CDR_GIOP_MINOR_VERSION); - - /// Returns @c false if an error has occurred. - bool good_bit (void) const; - - /// Reset current size. - void reset (void); - - /// Return current size. - size_t total_length (void) const; - - // Return 0 on failure and 1 on success. - //@{ @name Size-calculating pseudo-write operations - ACE_CDR::Boolean write_boolean (ACE_CDR::Boolean x); - ACE_CDR::Boolean write_char (ACE_CDR::Char x); - ACE_CDR::Boolean write_wchar (ACE_CDR::WChar x); - ACE_CDR::Boolean write_octet (ACE_CDR::Octet x); - ACE_CDR::Boolean write_short (ACE_CDR::Short x); - ACE_CDR::Boolean write_ushort (ACE_CDR::UShort x); - ACE_CDR::Boolean write_long (ACE_CDR::Long x); - ACE_CDR::Boolean write_ulong (ACE_CDR::ULong x); - ACE_CDR::Boolean write_longlong (const ACE_CDR::LongLong &x); - ACE_CDR::Boolean write_ulonglong (const ACE_CDR::ULongLong &x); - ACE_CDR::Boolean write_float (ACE_CDR::Float x); - ACE_CDR::Boolean write_double (const ACE_CDR::Double &x); - ACE_CDR::Boolean write_longdouble (const ACE_CDR::LongDouble &x); - ACE_CDR::Boolean write_fixed (const ACE_CDR::Fixed &x); - - /// For string we offer methods that accept a precomputed length. - ACE_CDR::Boolean write_string (const ACE_CDR::Char *x); - ACE_CDR::Boolean write_string (ACE_CDR::ULong len, - const ACE_CDR::Char *x); - ACE_CDR::Boolean write_string (const ACE_CString &x); - ACE_CDR::Boolean write_wstring (const ACE_CDR::WChar *x); - ACE_CDR::Boolean write_wstring (ACE_CDR::ULong length, - const ACE_CDR::WChar *x); - ACE_CDR::Boolean write_string (const std::string &x); -#if !defined(ACE_LACKS_STD_WSTRING) - ACE_CDR::Boolean write_wstring (const std::wstring &x); -#endif - //@} - - /// @note the portion written starts at and ends - /// at . - /// The length is *NOT* stored into the CDR stream. - //@{ @name Array write operations - ACE_CDR::Boolean write_boolean_array (const ACE_CDR::Boolean *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_char_array (const ACE_CDR::Char *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_wchar_array (const ACE_CDR::WChar* x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_octet_array (const ACE_CDR::Octet* x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_short_array (const ACE_CDR::Short *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_ushort_array (const ACE_CDR::UShort *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_long_array (const ACE_CDR::Long *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_ulong_array (const ACE_CDR::ULong *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_longlong_array (const ACE_CDR::LongLong* x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_ulonglong_array (const ACE_CDR::ULongLong *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_float_array (const ACE_CDR::Float *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_double_array (const ACE_CDR::Double *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_longdouble_array (const ACE_CDR::LongDouble* x, - ACE_CDR::ULong length); - - /// - /// Adjust to @a size and count @a size octets. - void adjust (size_t size); - - /// As above, but now the size and alignment requirements may be - /// different. - void adjust (size_t size, - size_t align); - -private: - /// disallow copying... - ACE_SizeCDR (const ACE_SizeCDR& rhs); - ACE_SizeCDR& operator= (const ACE_SizeCDR& rhs); - - ACE_CDR::Boolean write_1 (const ACE_CDR::Octet *x); - ACE_CDR::Boolean write_2 (const ACE_CDR::UShort *x); - ACE_CDR::Boolean write_4 (const ACE_CDR::ULong *x); - ACE_CDR::Boolean write_8 (const ACE_CDR::ULongLong *x); - ACE_CDR::Boolean write_16 (const ACE_CDR::LongDouble *x); - - /** - * write an array of @a length elements, each of @a size bytes and the - * start aligned at a multiple of . The elements are assumed - * to be packed with the right alignment restrictions. It is mostly - * designed for buffers of the basic types. - * - * This operation uses ; as explained above it is expected - * that using assignment is faster that for one element, - * but for several elements should be more efficient, it - * could be interesting to find the break even point and optimize - * for that case, but that would be too platform dependent. - */ - ACE_CDR::Boolean write_array (const void *x, - size_t size, - size_t align, - ACE_CDR::ULong length); - - - ACE_CDR::Boolean write_wchar_array_i (const ACE_CDR::WChar* x, - ACE_CDR::ULong length); - -private: - /// Set to false when an error occurs. - bool good_bit_; - - /// Current size. - size_t size_; - -protected: - /// GIOP version information - ACE_CDR::Octet major_version_; - ACE_CDR::Octet minor_version_; -}; - -// @@ This operator should not be inlined since they force SString.h -// to be included in this header. -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - const ACE_CString &x); - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -# include "ace/CDR_Size.inl" -#else /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Not used by CORBA or TAO -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_CDR::Char x); - -// CDR size-calculating output operators for primitive types - -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_CDR::Short x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_CDR::UShort x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_CDR::Long x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_CDR::ULong x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_CDR::LongLong x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_CDR::ULongLong x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR& ss, - ACE_CDR::LongDouble x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_CDR::Float x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_CDR::Double x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - const ACE_CDR::Fixed &x); - -// CDR size-calculating output operator from helper classes - -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_OutputCDR::from_boolean x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_OutputCDR::from_char x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_OutputCDR::from_wchar x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_OutputCDR::from_octet x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_OutputCDR::from_string x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - ACE_OutputCDR::from_wstring x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - const ACE_CDR::Char* x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - const ACE_CDR::WChar* x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - const std::string& x); -#if !defined(ACE_LACKS_STD_WSTRING) -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_SizeCDR &ss, - const std::wstring& x); -#endif - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* __ACE_INLINE__ */ - - -#include /**/ "ace/post.h" - -#endif /* ACE_CDR_SIZE_H */ diff --git a/deps/acelite/ace/CDR_Size.inl b/deps/acelite/ace/CDR_Size.inl deleted file mode 100644 index d138b3de1..000000000 --- a/deps/acelite/ace/CDR_Size.inl +++ /dev/null @@ -1,471 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_SizeCDR::ACE_SizeCDR (ACE_CDR::Octet major_version, - ACE_CDR::Octet minor_version) - : good_bit_ (true), - size_ (0), - major_version_ (major_version), - minor_version_ (minor_version) -{ -} - -ACE_INLINE bool -ACE_SizeCDR::good_bit (void) const -{ - return this->good_bit_; -} - -ACE_INLINE void -ACE_SizeCDR::reset (void) -{ - this->size_ = 0; -} - -ACE_INLINE size_t -ACE_SizeCDR::total_length (void) const -{ - return this->size_; -} - - -// Encode the CDR stream. - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_octet (ACE_CDR::Octet x) -{ - return this->write_1 (reinterpret_cast (&x)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_boolean (ACE_CDR::Boolean x) -{ - return (ACE_CDR::Boolean) this->write_octet (x ? (ACE_CDR::Octet) 1 : (ACE_CDR::Octet) 0); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_char (ACE_CDR::Char x) -{ - // Note: translator framework is not supported. - // - return this->write_1 (reinterpret_cast (&x)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_short (ACE_CDR::Short x) -{ - return this->write_2 (reinterpret_cast (&x)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_ushort (ACE_CDR::UShort x) -{ - return this->write_2 (reinterpret_cast (&x)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_long (ACE_CDR::Long x) -{ - return this->write_4 (reinterpret_cast (&x)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_ulong (ACE_CDR::ULong x) -{ - return this->write_4 (reinterpret_cast (&x)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_longlong (const ACE_CDR::LongLong &x) -{ - return this->write_8 (reinterpret_cast (&x)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_ulonglong (const ACE_CDR::ULongLong &x) -{ - const void *temp = &x; - return this->write_8 (reinterpret_cast (temp)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_float (ACE_CDR::Float x) -{ - const void *temp = &x; - return this->write_4 (reinterpret_cast (temp)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_double (const ACE_CDR::Double &x) -{ - const void *temp = &x; - return this->write_8 (reinterpret_cast (temp)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_longdouble (const ACE_CDR::LongDouble &x) -{ - const void *temp = &x; - return this->write_16 (reinterpret_cast (temp)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_fixed (const ACE_CDR::Fixed &x) -{ - return this->write_array (&x, ACE_CDR::OCTET_SIZE, ACE_CDR::OCTET_ALIGN, - (x.fixed_digits () + 2) / 2); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_string (const ACE_CDR::Char *x) -{ - if (x != 0) - { - const ACE_CDR::ULong len = - static_cast (ACE_OS::strlen (x)); - return this->write_string (len, x); - } - return this->write_string (0, 0); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_wstring (const ACE_CDR::WChar *x) -{ - if (x != 0) - { - ACE_CDR::ULong len = - static_cast (ACE_OS::strlen (x)); - return this->write_wstring (len, x); - } - return this->write_wstring (0, 0); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_string (const std::string &x) -{ - ACE_CDR::ULong len = - static_cast (x.size ()); - return this->write_string (len, - x.empty () ? 0 : x.c_str ()); -} - -#if !defined(ACE_LACKS_STD_WSTRING) -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_wstring (const std::wstring &x) -{ - ACE_CDR::ULong len = - static_cast (x.size ()); - return this->write_wstring (len, - x.empty () ? 0 : x.c_str ()); -} -#endif - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_char_array (const ACE_CDR::Char *x, - ACE_CDR::ULong length) -{ - // Note: translator framework is not supported. - // - return this->write_array (x, - ACE_CDR::OCTET_SIZE, - ACE_CDR::OCTET_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_wchar_array (const ACE_CDR::WChar* x, - ACE_CDR::ULong length) -{ - // Note: translator framework is not supported. - // - if (ACE_OutputCDR::wchar_maxbytes () == 0) - { - errno = EACCES; - return (ACE_CDR::Boolean) (this->good_bit_ = false); - } - if (ACE_OutputCDR::wchar_maxbytes () == sizeof (ACE_CDR::WChar)) - return this->write_array (x, - sizeof (ACE_CDR::WChar), - sizeof (ACE_CDR::WChar) == 2 - ? ACE_CDR::SHORT_ALIGN - : ACE_CDR::LONG_ALIGN, - length); - return this->write_wchar_array_i (x,length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_octet_array (const ACE_CDR::Octet* x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::OCTET_SIZE, - ACE_CDR::OCTET_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_short_array (const ACE_CDR::Short *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::SHORT_SIZE, - ACE_CDR::SHORT_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_ushort_array (const ACE_CDR::UShort *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::SHORT_SIZE, - ACE_CDR::SHORT_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_long_array (const ACE_CDR::Long *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONG_SIZE, - ACE_CDR::LONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_ulong_array (const ACE_CDR::ULong *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONG_SIZE, - ACE_CDR::LONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_longlong_array (const ACE_CDR::LongLong *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONGLONG_SIZE, - ACE_CDR::LONGLONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_ulonglong_array (const ACE_CDR::ULongLong *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONGLONG_SIZE, - ACE_CDR::LONGLONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_float_array (const ACE_CDR::Float *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONG_SIZE, - ACE_CDR::LONG_ALIGN, - length); -} - - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_double_array (const ACE_CDR::Double *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONGLONG_SIZE, - ACE_CDR::LONGLONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_SizeCDR::write_longdouble_array (const ACE_CDR::LongDouble* x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONGDOUBLE_SIZE, - ACE_CDR::LONGDOUBLE_ALIGN, - length); -} - - -// **************************************************************** - - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_CDR::Char x) -{ - ss.write_char (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_CDR::Short x) -{ - ss.write_short (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_CDR::UShort x) -{ - ss.write_ushort (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_CDR::Long x) -{ - ss.write_long (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_CDR::ULong x) -{ - ss.write_ulong (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_CDR::LongLong x) -{ - ss.write_longlong (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_CDR::ULongLong x) -{ - ss.write_ulonglong (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_CDR::LongDouble x) -{ - ss.write_longdouble (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_CDR::Float x) -{ - ss.write_float (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_CDR::Double x) -{ - ss.write_double (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, const ACE_CDR::Fixed &x) -{ - ss.write_fixed (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, const ACE_CDR::Char *x) -{ - ss.write_string (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, const ACE_CDR::WChar *x) -{ - ss.write_wstring (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, const std::string& x) -{ - ss.write_string (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -#if !defined(ACE_LACKS_STD_WSTRING) -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, const std::wstring& x) -{ - ss.write_wstring (x); - return (ACE_CDR::Boolean) ss.good_bit (); -} -#endif - -// The following use the helper classes -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_boolean x) -{ - ss.write_boolean (x.val_); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_char x) -{ - ss.write_char (x.val_); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_wchar x) -{ - ss.write_wchar (x.val_); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_octet x) -{ - ss.write_octet (x.val_); - return (ACE_CDR::Boolean) ss.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_string x) -{ - ACE_CDR::ULong len = 0; - - if (x.val_ != 0) - { - len = static_cast (ACE_OS::strlen (x.val_)); - } - - ss.write_string (len, x.val_); - return - (ACE_CDR::Boolean) (ss.good_bit () && (!x.bound_ || len <= x.bound_)); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_SizeCDR &ss, ACE_OutputCDR::from_wstring x) -{ - ACE_CDR::ULong len = 0; - - if (x.val_ != 0) - { - len = static_cast (ACE_OS::strlen (x.val_)); - } - - ss.write_wstring (len, x.val_); - return - (ACE_CDR::Boolean) (ss.good_bit () && (!x.bound_ || len <= x.bound_)); -} - - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/CDR_Stream.cpp b/deps/acelite/ace/CDR_Stream.cpp deleted file mode 100644 index 32654aedd..000000000 --- a/deps/acelite/ace/CDR_Stream.cpp +++ /dev/null @@ -1,2452 +0,0 @@ -#include "ace/CDR_Stream.h" -#include "ace/SString.h" -#include "ace/Auto_Ptr.h" -#include "ace/Truncate.h" - -#if !defined (__ACE_INLINE__) -# include "ace/CDR_Stream.inl" -#endif /* ! __ACE_INLINE__ */ - -// **************************************************************** - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -size_t ACE_OutputCDR::wchar_maxbytes_ = sizeof (ACE_CDR::WChar); - -ACE_OutputCDR::ACE_OutputCDR (size_t size, - int byte_order, - ACE_Allocator *buffer_allocator, - ACE_Allocator *data_block_allocator, - ACE_Allocator *message_block_allocator, - size_t memcpy_tradeoff, - ACE_CDR::Octet major_version, - ACE_CDR::Octet minor_version) - : start_ ((size ? size : (size_t) ACE_CDR::DEFAULT_BUFSIZE) + ACE_CDR::MAX_ALIGNMENT, - ACE_Message_Block::MB_DATA, - 0, - 0, - buffer_allocator, - 0, - 0, - ACE_Time_Value::zero, - ACE_Time_Value::max_time, - data_block_allocator, - message_block_allocator), -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - current_alignment_ (0), -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - current_is_writable_ (true), - do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER), - good_bit_ (true), - memcpy_tradeoff_ (memcpy_tradeoff), - major_version_ (major_version), - minor_version_ (minor_version), - char_translator_ (0), - wchar_translator_ (0) - -{ - ACE_CDR::mb_align (&this->start_); - this->current_ = &this->start_; - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (this->total_length ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_OutputCDR::ACE_OutputCDR (char *data, - size_t size, - int byte_order, - ACE_Allocator *buffer_allocator, - ACE_Allocator *data_block_allocator, - ACE_Allocator *message_block_allocator, - size_t memcpy_tradeoff, - ACE_CDR::Octet major_version, - ACE_CDR::Octet minor_version) - : start_ (size, - ACE_Message_Block::MB_DATA, - 0, - data, - buffer_allocator, - 0, - 0, - ACE_Time_Value::zero, - ACE_Time_Value::max_time, - data_block_allocator, - message_block_allocator), -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - current_alignment_ (0), -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - current_is_writable_ (true), - do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER), - good_bit_ (true), - memcpy_tradeoff_ (memcpy_tradeoff), - major_version_ (major_version), - minor_version_ (minor_version), - char_translator_ (0), - wchar_translator_ (0) -{ - // We cannot trust the buffer to be properly aligned - ACE_CDR::mb_align (&this->start_); - this->current_ = &this->start_; - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (this->total_length ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_OutputCDR::ACE_OutputCDR (ACE_Data_Block *data_block, - int byte_order, - ACE_Allocator *message_block_allocator, - size_t memcpy_tradeoff, - ACE_CDR::Octet major_version, - ACE_CDR::Octet minor_version) - : start_ (data_block, - ACE_Message_Block::DONT_DELETE, - message_block_allocator), -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - current_alignment_ (0), -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - current_is_writable_ (true), - do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER), - good_bit_ (true), - memcpy_tradeoff_ (memcpy_tradeoff), - major_version_ (major_version), - minor_version_ (minor_version), - char_translator_ (0), - wchar_translator_ (0) -{ - // We cannot trust the buffer to be properly aligned - ACE_CDR::mb_align (&this->start_); - this->current_ = &this->start_; - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (this->total_length ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_OutputCDR::ACE_OutputCDR (ACE_Message_Block *data, - int byte_order, - size_t memcpy_tradeoff, - ACE_CDR::Octet major_version, - ACE_CDR::Octet minor_version) - : start_ (data->data_block ()->duplicate ()), -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - current_alignment_ (0), -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - current_is_writable_ (true), - do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER), - good_bit_ (true), - memcpy_tradeoff_ (memcpy_tradeoff), - major_version_ (major_version), - minor_version_ (minor_version), - char_translator_ (0), - wchar_translator_ (0) -{ - // We cannot trust the buffer to be properly aligned - ACE_CDR::mb_align (&this->start_); - this->current_ = &this->start_; - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (this->total_length ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -/*static*/ void -ACE_OutputCDR::wchar_maxbytes (size_t maxbytes) -{ - ACE_OutputCDR::wchar_maxbytes_ = maxbytes; -} - -/*static*/ size_t -ACE_OutputCDR::wchar_maxbytes () -{ - return ACE_OutputCDR::wchar_maxbytes_; -} - -int -ACE_OutputCDR::grow_and_adjust (size_t size, - size_t align, - char*& buf) -{ - if (!this->current_is_writable_ - || this->current_->cont () == 0 - || this->current_->cont ()->size () < size + ACE_CDR::MAX_ALIGNMENT) - { - // Calculate the new buffer's length; if growing for encode, we - // don't grow in "small" chunks because of the cost. - size_t cursize = this->current_->size (); - if (this->current_->cont () != 0) - cursize = this->current_->cont ()->size (); - size_t minsize = size; - -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - minsize += ACE_CDR::MAX_ALIGNMENT; -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - - // Make sure that there is enough room for bytes, but - // also make it bigger than whatever our current size is. - if (minsize < cursize) - minsize = cursize; - - size_t const newsize = ACE_CDR::next_size (minsize); - - this->good_bit_ = false; - ACE_Message_Block* tmp = 0; - ACE_NEW_RETURN (tmp, - ACE_Message_Block (newsize, - ACE_Message_Block::MB_DATA, - 0, - 0, - this->current_->data_block ()->allocator_strategy (), - 0, - 0, - ACE_Time_Value::zero, - ACE_Time_Value::max_time, - this->current_->data_block ()->data_block_allocator ()), - -1); - - // Message block initialization may fail while the construction - // succeds. Since as a matter of policy, ACE may throw no - // exceptions, we have to do a separate check like this. - if (tmp != 0 && tmp->size () < newsize) - { - delete tmp; - errno = ENOMEM; - return -1; - } - - this->good_bit_ = true; - -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - // The new block must start with the same alignment as the - // previous block finished. - ptrdiff_t const tmpalign = - reinterpret_cast (tmp->rd_ptr ()) % ACE_CDR::MAX_ALIGNMENT; - ptrdiff_t const curalign = - static_cast (this->current_alignment_) % ACE_CDR::MAX_ALIGNMENT; - ptrdiff_t offset = curalign - tmpalign; - if (offset < 0) - offset += ACE_CDR::MAX_ALIGNMENT; - tmp->rd_ptr (static_cast (offset)); - tmp->wr_ptr (tmp->rd_ptr ()); -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - - // grow the chain and set the current block. - tmp->cont (this->current_->cont ()); - this->current_->cont (tmp); - } - this->current_ = this->current_->cont (); - this->current_is_writable_ = true; - - return this->adjust (size, align, buf); -} - -ACE_CDR::Boolean -ACE_OutputCDR::write_wchar (ACE_CDR::WChar x) -{ - if (this->wchar_translator_ != 0) - return (this->good_bit_ = this->wchar_translator_->write_wchar (*this, x)); - if (ACE_OutputCDR::wchar_maxbytes_ == 0) - { - errno = EACCES; - return (this->good_bit_ = false); - } - if (static_cast (major_version_) == 1 - && static_cast (minor_version_) == 2) - { - ACE_CDR::Octet len = - static_cast (ACE_OutputCDR::wchar_maxbytes_); - if (this->write_1 (&len)) - { - if (ACE_OutputCDR::wchar_maxbytes_ == sizeof(ACE_CDR::WChar)) - return - this->write_octet_array ( - reinterpret_cast (&x), - static_cast (len)); - else - if (ACE_OutputCDR::wchar_maxbytes_ == 2) - { - ACE_CDR::Short sx = static_cast (x); - return - this->write_octet_array ( - reinterpret_cast (&sx), - static_cast (len)); - } - else - { - ACE_CDR::Octet ox = static_cast (x); - return - this->write_octet_array ( - reinterpret_cast (&ox), - static_cast (len)); - } - } - } - else if (static_cast (minor_version_) == 0) - { // wchar is not allowed with GIOP 1.0. - errno = EINVAL; - return (this->good_bit_ = false); - } - if (ACE_OutputCDR::wchar_maxbytes_ == sizeof (ACE_CDR::WChar)) - { - void const * const temp = &x; - return - this->write_4 (reinterpret_cast (temp)); - } - else if (ACE_OutputCDR::wchar_maxbytes_ == 2) - { - ACE_CDR::Short sx = static_cast (x); - return this->write_2 (reinterpret_cast (&sx)); - } - ACE_CDR::Octet ox = static_cast (x); - return this->write_1 (reinterpret_cast (&ox)); -} - -ACE_CDR::Boolean -ACE_OutputCDR::write_string (ACE_CDR::ULong len, - const ACE_CDR::Char *x) -{ - // @@ This is a slight violation of "Optimize for the common case", - // i.e. normally the translator will be 0, but OTOH the code is - // smaller and should be better for the cache ;-) ;-) - if (this->char_translator_ != 0) - return this->char_translator_->write_string (*this, len, x); - - if (len != 0) - { - if (this->write_ulong (len + 1)) - return this->write_char_array (x, len + 1); - } - else - { - // Be nice to programmers: treat nulls as empty strings not - // errors. (OMG-IDL supports languages that don't use the C/C++ - // notion of null v. empty strings; nulls aren't part of the OMG-IDL - // string model.) - if (this->write_ulong (1)) - return this->write_char (0); - } - - return (this->good_bit_ = false); -} - -ACE_CDR::Boolean -ACE_OutputCDR::write_string (const ACE_CString &x) -{ - // @@ Leave this method in here, not the `.i' file so that we don't - // have to unnecessarily pull in the `ace/SString.h' header. - return this->write_string (static_cast (x.length ()), - x.c_str()); -} - -ACE_CDR::Boolean -ACE_OutputCDR::write_wstring (ACE_CDR::ULong len, - const ACE_CDR::WChar *x) -{ - // @@ This is a slight violation of "Optimize for the common case", - // i.e. normally the translator will be 0, but OTOH the code is - // smaller and should be better for the cache ;-) ;-) - // What do we do for GIOP 1.2??? - if (this->wchar_translator_ != 0) - return this->wchar_translator_->write_wstring (*this, len, x); - if (ACE_OutputCDR::wchar_maxbytes_ == 0) - { - errno = EACCES; - return (this->good_bit_ = false); - } - - if (static_cast (this->major_version_) == 1 - && static_cast (this->minor_version_) == 2) - { - if (x != 0) - { - //In GIOP 1.2 the length field contains the number of bytes - //the wstring occupies rather than number of wchars - //Taking sizeof might not be a good way! This is a temporary fix. - ACE_CDR::Boolean good_ulong = - this->write_ulong ( - ACE_Utils::truncate_cast ( - ACE_OutputCDR::wchar_maxbytes_ * len)); - - if (good_ulong) - { - return this->write_wchar_array (x, len); - } - } - else - { - //In GIOP 1.2 zero length wstrings are legal - return this->write_ulong (0); - } - } - - else - if (x != 0) - { - if (this->write_ulong (len + 1)) - return this->write_wchar_array (x, len + 1); - } - else if (this->write_ulong (1)) - return this->write_wchar (0); - return (this->good_bit_ = false); -} - -ACE_CDR::Boolean -ACE_OutputCDR::write_octet_array_mb (const ACE_Message_Block* mb) -{ - // If the buffer is small and it fits in the current message - // block it is be cheaper just to copy the buffer. - for (const ACE_Message_Block* i = mb; - i != 0; - i = i->cont ()) - { - size_t const length = i->length (); - - // If the mb does not own its data we are forced to make a copy. - if (ACE_BIT_ENABLED (i->flags (), - ACE_Message_Block::DONT_DELETE)) - { - if (! this->write_array (i->rd_ptr (), - ACE_CDR::OCTET_SIZE, - ACE_CDR::OCTET_ALIGN, - static_cast (length))) - return (this->good_bit_ = false); - continue; - } - - if (length < this->memcpy_tradeoff_ - && this->current_->wr_ptr () + length < this->current_->end ()) - { - if (! this->write_array (i->rd_ptr (), - ACE_CDR::OCTET_SIZE, - ACE_CDR::OCTET_ALIGN, - static_cast (length))) - return (this->good_bit_ = false); - continue; - } - - ACE_Message_Block* cont = 0; - this->good_bit_ = false; - ACE_NEW_RETURN (cont, - ACE_Message_Block (i->data_block ()->duplicate ()), - false); - this->good_bit_ = true; - - if (this->current_->cont () != 0) - ACE_Message_Block::release (this->current_->cont ()); - cont->rd_ptr (i->rd_ptr ()); - cont->wr_ptr (i->wr_ptr ()); - - this->current_->cont (cont); - this->current_ = cont; - this->current_is_writable_ = false; -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - this->current_alignment_ = - (this->current_alignment_ + cont->length ()) % ACE_CDR::MAX_ALIGNMENT; -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - } - - return true; -} - -ACE_CDR::Boolean -ACE_OutputCDR::write_1 (const ACE_CDR::Octet *x) -{ - char *buf = 0; - if (this->adjust (1, buf) == 0) - { - *reinterpret_cast (buf) = *x; - return true; - } - - return false; -} - -ACE_CDR::Boolean -ACE_OutputCDR::write_2 (const ACE_CDR::UShort *x) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::SHORT_SIZE, buf) == 0) - { -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *reinterpret_cast (buf) = *x; - return true; -#else - if (!this->do_byte_swap_) - { - *reinterpret_cast (buf) = *x; - return true; - } - else - { - ACE_CDR::swap_2 (reinterpret_cast (x), buf); - return true; - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - } - - return false; -} - -ACE_CDR::Boolean -ACE_OutputCDR::write_4 (const ACE_CDR::ULong *x) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::LONG_SIZE, buf) == 0) - { -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *reinterpret_cast (buf) = *x; - return true; -#else - if (!this->do_byte_swap_) - { - *reinterpret_cast (buf) = *x; - return true; - } - else - { - ACE_CDR::swap_4 (reinterpret_cast (x), buf); - return true; - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - } - - return false; -} - -ACE_CDR::Boolean -ACE_OutputCDR::write_8 (const ACE_CDR::ULongLong *x) -{ - char *buf = 0; - - if (this->adjust (ACE_CDR::LONGLONG_SIZE, buf) == 0) - { -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *reinterpret_cast (buf) = *x; - return true; -#else - if (!this->do_byte_swap_) - { - *reinterpret_cast (buf) = *x; - return true; - } - else - { - ACE_CDR::swap_8 (reinterpret_cast (x), buf); - return true; - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - } - - return false; -} - -ACE_CDR::Boolean -ACE_OutputCDR::write_16 (const ACE_CDR::LongDouble *x) -{ - char* buf = 0; - if (this->adjust (ACE_CDR::LONGDOUBLE_SIZE, - ACE_CDR::LONGDOUBLE_ALIGN, - buf) == 0) - { -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *reinterpret_cast (buf) = *x; - return 1; -#else - if (!this->do_byte_swap_) - { - *reinterpret_cast (buf) = *x; - return true; - } - else - { - ACE_CDR::swap_16 (reinterpret_cast (x), buf); - return true; - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - } - - return false; -} - -ACE_CDR::Boolean -ACE_OutputCDR::write_wchar_array_i (const ACE_CDR::WChar *x, - ACE_CDR::ULong length) -{ - if (length == 0) - return true; - char* buf = 0; - size_t const align = (ACE_OutputCDR::wchar_maxbytes_ == 2) ? - ACE_CDR::SHORT_ALIGN : - ACE_CDR::OCTET_ALIGN; - - if (this->adjust (ACE_OutputCDR::wchar_maxbytes_ * length, align, buf) == 0) - { - if (ACE_OutputCDR::wchar_maxbytes_ == 2) - { - ACE_CDR::UShort *sb = reinterpret_cast (buf); - for (size_t i = 0; i < length; ++i) -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - sb[i] = static_cast (x[i]); -#else - if (!this->do_byte_swap_) - sb[i] = static_cast (x[i]); - else - { - ACE_CDR::UShort sx = static_cast (x[i]); - ACE_CDR::swap_2 (reinterpret_cast (&sx), &buf[i * 2]); - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - } - else - { - for (size_t i = 0; i < length; ++i) - buf[i] = static_cast (x[i]); - } - return this->good_bit_; - } - return false; -} - - -ACE_CDR::Boolean -ACE_OutputCDR::write_array (const void *x, - size_t size, - size_t align, - ACE_CDR::ULong length) -{ - if (length == 0) - return true; - char *buf = 0; - if (this->adjust (size * length, align, buf) == 0) - { -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - ACE_OS::memcpy (buf, x, size*length); - return true; -#else - if (!this->do_byte_swap_ || size == 1) - { - ACE_OS::memcpy (buf, x, size*length); - return true; - } - else - { - const char *source = reinterpret_cast (x); - switch (size) - { - case 2: - ACE_CDR::swap_2_array (source, buf, length); - return true; - case 4: - ACE_CDR::swap_4_array (source, buf, length); - return true; - case 8: - ACE_CDR::swap_8_array (source, buf, length); - return true; - case 16: - ACE_CDR::swap_16_array (source, buf, length); - return true; - default: - // TODO: print something? - this->good_bit_ = false; - return false; - } - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - } - this->good_bit_ = false; - return false; -} - - -ACE_CDR::Boolean -ACE_OutputCDR::write_boolean_array (const ACE_CDR::Boolean* x, - ACE_CDR::ULong length) -{ - // It is hard to optimize this, the spec requires that on the wire - // booleans be represented as a byte with value 0 or 1, but in - // memory it is possible (though very unlikely) that a boolean has - // a non-zero value (different from 1). - // We resort to a simple loop. - ACE_CDR::Boolean const * const end = x + length; - - for (ACE_CDR::Boolean const * i = x; - i != end && this->good_bit (); - ++i) - (void) this->write_boolean (*i); - - return this->good_bit (); -} - -char * -ACE_OutputCDR::write_long_placeholder (void) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::LONG_SIZE, buf) == 0) - *reinterpret_cast (buf) = 0; - else - buf = 0; - return buf; -} - -char * -ACE_OutputCDR::write_short_placeholder (void) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::SHORT_SIZE, buf) == 0) - *reinterpret_cast (buf) = 0; - else - buf = 0; - return buf; -} - -char * -ACE_OutputCDR::write_boolean_placeholder (void) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::OCTET_SIZE, buf) == 0) - *reinterpret_cast (buf) = 0; - else - buf = 0; - return buf; -} - -char * -ACE_OutputCDR::write_char_placeholder (void) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::OCTET_SIZE, buf) == 0) - *reinterpret_cast (buf) = 0; - else - buf = 0; - return buf; -} - -char * -ACE_OutputCDR::write_octet_placeholder (void) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::OCTET_SIZE, buf) == 0) - *reinterpret_cast (buf) = 0; - else - buf = 0; - return buf; -} - -char * -ACE_OutputCDR::write_longlong_placeholder (void) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::LONGLONG_SIZE, buf) == 0) - *reinterpret_cast (buf) = 0; - else - buf = 0; - return buf; -} - -char * -ACE_OutputCDR::write_float_placeholder (void) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::LONG_SIZE, buf) == 0) - *reinterpret_cast (buf) = 0; - else - buf = 0; - return buf; -} - -char * -ACE_OutputCDR::write_double_placeholder (void) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::LONGLONG_SIZE, buf) == 0) - *reinterpret_cast (buf) = 0; - else - buf = 0; - return buf; -} - -ACE_CDR::Boolean -ACE_OutputCDR::replace (ACE_CDR::Long x, char* loc) -{ - if (this->find (loc) == 0) - return false; - -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *reinterpret_cast (loc) = x; -#else - if (!this->do_byte_swap_) - { - *reinterpret_cast (loc) = x; - } - else - { - ACE_CDR::swap_4 (reinterpret_cast (&x), loc); - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - - return true; -} - -ACE_CDR::Boolean -ACE_OutputCDR::replace (ACE_CDR::ULong x, char* loc) -{ - if (this->find (loc) == 0) - return false; - -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *reinterpret_cast (loc) = x; -#else - if (!this->do_byte_swap_) - { - *reinterpret_cast (loc) = x; - } - else - { - ACE_CDR::swap_4 (reinterpret_cast (&x), loc); - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - - return true; -} - -ACE_CDR::Boolean -ACE_OutputCDR::replace (ACE_CDR::Short x, char* loc) -{ - if (this->find (loc) == 0) - return false; - -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *reinterpret_cast (loc) = x; -#else - if (!this->do_byte_swap_) - { - *reinterpret_cast (loc) = x; - } - else - { - ACE_CDR::swap_2 (reinterpret_cast (&x), loc); - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - - return true; -} - -ACE_CDR::Boolean -ACE_OutputCDR::replace (ACE_CDR::UShort x, char* loc) -{ - if (this->find (loc) == 0) - return false; - -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *reinterpret_cast (loc) = x; -#else - if (!this->do_byte_swap_) - { - *reinterpret_cast (loc) = x; - } - else - { - ACE_CDR::swap_2 (reinterpret_cast (&x), loc); - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - - return true; -} - -ACE_CDR::Boolean -ACE_OutputCDR::replace (ACE_CDR::Boolean x, char* loc) -{ - if (this->find (loc) == 0) - return false; - - *reinterpret_cast (loc) = x; - - return true; -} - -ACE_CDR::Boolean -ACE_OutputCDR::replace (ACE_CDR::Char x, char* loc) -{ - if (this->find (loc) == 0) - return false; - - *reinterpret_cast (loc) = x; - - return true; -} - -ACE_CDR::Boolean -ACE_OutputCDR::replace (ACE_CDR::Octet x, char* loc) -{ - if (this->find (loc) == 0) - return false; - - *reinterpret_cast (loc) = x; - - return true; -} - -ACE_CDR::Boolean -ACE_OutputCDR::replace (ACE_CDR::LongLong x, char* loc) -{ - if (this->find (loc) == 0) - return false; - -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *reinterpret_cast (loc) = x; -#else - if (!this->do_byte_swap_) - { - *reinterpret_cast (loc) = x; - } - else - { - ACE_CDR::swap_8 (reinterpret_cast (&x), loc); - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - - return true; -} - -ACE_CDR::Boolean -ACE_OutputCDR::replace (ACE_CDR::ULongLong x, char* loc) -{ - if (this->find (loc) == 0) - return false; - -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *reinterpret_cast (loc) = x; -#else - if (!this->do_byte_swap_) - { - *reinterpret_cast (loc) = x; - } - else - { - ACE_CDR::swap_8 (reinterpret_cast (&x), loc); - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - - return true; -} - -ACE_CDR::Boolean -ACE_OutputCDR::replace (ACE_CDR::Float x, char* loc) -{ - if (this->find (loc) == 0) - return false; - -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *reinterpret_cast (loc) = x; -#else - if (!this->do_byte_swap_) - { - *reinterpret_cast (loc) = x; - } - else - { - ACE_CDR::swap_4 (reinterpret_cast (&x), loc); - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - - return true; -} - -ACE_CDR::Boolean -ACE_OutputCDR::replace (ACE_CDR::Double x, char* loc) -{ - if (this->find (loc) == 0) - return false; - -#if !defined (ACE_ENABLE_SWAP_ON_WRITE) - *reinterpret_cast (loc) = x; -#else - if (!this->do_byte_swap_) - { - *reinterpret_cast (loc) = x; - } - else - { - ACE_CDR::swap_8 (reinterpret_cast (&x), loc); - } -#endif /* ACE_ENABLE_SWAP_ON_WRITE */ - - return true; -} - -int -ACE_OutputCDR::consolidate (void) -{ - // Optimize by only doing something if we need to - if (this->current_ != &this->start_) - { - // Set the number of bytes in the top-level block, reallocating - // if necessary. The rd_ptr and wr_ptr remain at the original offsets - // into the buffer, even if it is reallocated. - // Return an error if the allocation failed. - size_t const newsize = - ACE_CDR::first_size (this->total_length () - + ACE_CDR::MAX_ALIGNMENT); - if (this->start_.size (newsize) < 0) - { - return -1; - } - - // Consolidate the chain into the first block. NOTE that - // ACE_CDR::consolidate can not be used since we don't want to - // overwrite what is already in the first block. We just append it since - // the read and write pointers weren't affected by the resizing above. - // We also don't have to worry about alignment since the start block is - // already aligned. - // NOTE also we know there is a continuation since we checked for it - // above. There is therefore no reason to check for a 0 continuation - // field here. - ACE_Message_Block *cont = this->start_.cont (); - for (const ACE_Message_Block* i = cont; i != 0; i = i->cont ()) - { - this->start_.copy (i->rd_ptr (), i->length ()); - } - - // Release the old blocks that were consolidated and reset the - // current_ and current_is_writable_ to reflect the single used block. - ACE_Message_Block::release (cont); - this->start_.cont (0); - this->current_ = &this->start_; - this->current_is_writable_ = true; - } - - return 0; -} - - -ACE_Message_Block* -ACE_OutputCDR::find (char* loc) -{ - ACE_Message_Block* mb = 0; - for (mb = &this->start_; mb != 0; mb = mb->cont ()) - { - if (loc <= mb->wr_ptr () && loc >= mb->rd_ptr ()) - { - break; - } - } - - return mb; -} - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - -void -ACE_OutputCDR::register_monitor (const char *id) -{ - this->monitor_->name (id); - this->monitor_->add_to_registry (); -} - -void -ACE_OutputCDR::unregister_monitor (void) -{ - this->monitor_->remove_from_registry (); -} - -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - -// **************************************************************** - -ACE_InputCDR::ACE_InputCDR (const char *buf, - size_t bufsiz, - int byte_order, - ACE_CDR::Octet major_version, - ACE_CDR::Octet minor_version) - : start_ (buf, bufsiz), - do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER), - good_bit_ (true), - major_version_ (major_version), - minor_version_ (minor_version), - char_translator_ (0), - wchar_translator_ (0) -{ - this->start_.wr_ptr (bufsiz); - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (bufsiz); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_InputCDR::ACE_InputCDR (size_t bufsiz, - int byte_order, - ACE_CDR::Octet major_version, - ACE_CDR::Octet minor_version) - : start_ (bufsiz), - do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER), - good_bit_ (true), - major_version_ (major_version), - minor_version_ (minor_version), - char_translator_ (0), - wchar_translator_ (0) -{ -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (bufsiz); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_InputCDR::ACE_InputCDR (const ACE_Message_Block *data, - int byte_order, - ACE_CDR::Octet major_version, - ACE_CDR::Octet minor_version, - ACE_Lock* lock) - : start_ (0, ACE_Message_Block::MB_DATA, 0, 0, 0, lock), - good_bit_ (true), - major_version_ (major_version), - minor_version_ (minor_version), - char_translator_ (0), - wchar_translator_ (0) -{ -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - - this->reset (data, byte_order); -} - -ACE_InputCDR::ACE_InputCDR (ACE_Data_Block *data, - ACE_Message_Block::Message_Flags flag, - int byte_order, - ACE_CDR::Octet major_version, - ACE_CDR::Octet minor_version) - : start_ (data, flag), - do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER), - good_bit_ (true), - major_version_ (major_version), - minor_version_ (minor_version), - char_translator_ (0), - wchar_translator_ (0) -{ -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (data->size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_InputCDR::ACE_InputCDR (ACE_Data_Block *data, - ACE_Message_Block::Message_Flags flag, - size_t rd_pos, - size_t wr_pos, - int byte_order, - ACE_CDR::Octet major_version, - ACE_CDR::Octet minor_version) - : start_ (data, flag), - do_byte_swap_ (byte_order != ACE_CDR_BYTE_ORDER), - good_bit_ (true), - major_version_ (major_version), - minor_version_ (minor_version), - char_translator_ (0), - wchar_translator_ (0) -{ - // Set the read pointer - this->start_.rd_ptr (rd_pos); - - // Set the write pointer after doing a sanity check. - char* wrpos = this->start_.base () + wr_pos; - - if (this->start_.end () >= wrpos) - { - this->start_.wr_ptr (wr_pos); - } - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (data->size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_InputCDR::ACE_InputCDR (const ACE_InputCDR& rhs, - size_t size, - ACE_CDR::Long offset) - : start_ (rhs.start_, - ACE_CDR::MAX_ALIGNMENT), - do_byte_swap_ (rhs.do_byte_swap_), - good_bit_ (true), - major_version_ (rhs.major_version_), - minor_version_ (rhs.minor_version_), - char_translator_ (rhs.char_translator_), - wchar_translator_ (rhs.wchar_translator_) -{ -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - // Align the base pointer assuming that the incoming stream is also - // aligned the way we are aligned - char *incoming_start = ACE_ptr_align_binary (rhs.start_.base (), - ACE_CDR::MAX_ALIGNMENT); -#else - char *incoming_start = rhs.start_.base (); -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - - const size_t newpos = - (rhs.start_.rd_ptr() - incoming_start) + offset; - - if (newpos <= this->start_.space () - && newpos + size <= this->start_.space ()) - { - this->start_.rd_ptr (newpos); - this->start_.wr_ptr (newpos + size); - } - else - { - this->good_bit_ = false; - } - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_InputCDR::ACE_InputCDR (const ACE_InputCDR& rhs, - size_t size) - : start_ (rhs.start_, - ACE_CDR::MAX_ALIGNMENT), - do_byte_swap_ (rhs.do_byte_swap_), - good_bit_ (true), - major_version_ (rhs.major_version_), - minor_version_ (rhs.minor_version_), - char_translator_ (rhs.char_translator_), - wchar_translator_ (rhs.wchar_translator_) -{ -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - // Align the base pointer assuming that the incoming stream is also - // aligned the way we are aligned - char *incoming_start = ACE_ptr_align_binary (rhs.start_.base (), - ACE_CDR::MAX_ALIGNMENT); -#else - char *incoming_start = rhs.start_.base (); -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - - const size_t newpos = - rhs.start_.rd_ptr() - incoming_start; - - if (newpos <= this->start_.space () - && newpos + size <= this->start_.space ()) - { - // Notice that ACE_Message_Block::duplicate may leave the - // wr_ptr() with a higher value than what we actually want. - this->start_.rd_ptr (newpos); - this->start_.wr_ptr (newpos + size); - - ACE_CDR::Octet byte_order = 0; - (void) this->read_octet (byte_order); - this->do_byte_swap_ = (byte_order != ACE_CDR_BYTE_ORDER); - } - else - { - this->good_bit_ = false; - } - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_InputCDR::ACE_InputCDR (const ACE_InputCDR& rhs) - : start_ (rhs.start_, - ACE_CDR::MAX_ALIGNMENT), - do_byte_swap_ (rhs.do_byte_swap_), - good_bit_ (true), - major_version_ (rhs.major_version_), - minor_version_ (rhs.minor_version_), - char_translator_ (rhs.char_translator_), - wchar_translator_ (rhs.wchar_translator_) -{ -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - char *buf = ACE_ptr_align_binary (rhs.start_.base (), - ACE_CDR::MAX_ALIGNMENT); -#else - char *buf = rhs.start_.base (); -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - - size_t rd_offset = rhs.start_.rd_ptr () - buf; - size_t wr_offset = rhs.start_.wr_ptr () - buf; - this->start_.rd_ptr (rd_offset); - this->start_.wr_ptr (wr_offset); - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_InputCDR::ACE_InputCDR (ACE_InputCDR::Transfer_Contents x) - : start_ (x.rhs_.start_.data_block ()), - do_byte_swap_ (x.rhs_.do_byte_swap_), - good_bit_ (true), - major_version_ (x.rhs_.major_version_), - minor_version_ (x.rhs_.minor_version_), - char_translator_ (x.rhs_.char_translator_), - wchar_translator_ (x.rhs_.wchar_translator_) -{ - this->start_.rd_ptr (x.rhs_.start_.rd_ptr ()); - this->start_.wr_ptr (x.rhs_.start_.wr_ptr ()); - - ACE_Data_Block* db = this->start_.data_block ()->clone_nocopy (); - (void) x.rhs_.start_.replace_data_block (db); - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_InputCDR& -ACE_InputCDR::operator= (const ACE_InputCDR& rhs) -{ - if (this != &rhs) - { - this->start_.data_block (rhs.start_.data_block ()->duplicate ()); - this->start_.rd_ptr (rhs.start_.rd_ptr ()); - this->start_.wr_ptr (rhs.start_.wr_ptr ()); - this->do_byte_swap_ = rhs.do_byte_swap_; - this->good_bit_ = true; - this->char_translator_ = rhs.char_translator_; - this->major_version_ = rhs.major_version_; - this->minor_version_ = rhs.minor_version_; - } - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - - return *this; -} - -ACE_InputCDR::ACE_InputCDR (const ACE_OutputCDR& rhs, - ACE_Allocator* buffer_allocator, - ACE_Allocator* data_block_allocator, - ACE_Allocator* message_block_allocator) - : start_ (rhs.total_length () + ACE_CDR::MAX_ALIGNMENT, - ACE_Message_Block::MB_DATA, - 0, - 0, - buffer_allocator, - 0, - 0, - ACE_Time_Value::zero, - ACE_Time_Value::max_time, - data_block_allocator, - message_block_allocator), - do_byte_swap_ (rhs.do_byte_swap_), - good_bit_ (true), - major_version_ (rhs.major_version_), - minor_version_ (rhs.minor_version_), - char_translator_ (rhs.char_translator_), - wchar_translator_ (rhs.wchar_translator_) -{ - ACE_CDR::mb_align (&this->start_); - for (const ACE_Message_Block *i = rhs.begin (); - i != rhs.end (); - i = i->cont ()) - { - this->start_.copy (i->rd_ptr (), i->length ()); - } - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE_NEW (this->monitor_, - ACE::Monitor_Control::Size_Monitor); - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_CDR::Boolean -ACE_InputCDR::skip_wchar (void) -{ - if (static_cast (major_version_) == 1 - && static_cast (minor_version_) == 2) - { - ACE_CDR::Octet len; - if (this->read_1 (&len)) - return this->skip_bytes (static_cast (len)); - } - else - { - ACE_CDR::WChar x; - void * const temp = &x; - if (ACE_OutputCDR::wchar_maxbytes_ == 2) - return this->read_2 (reinterpret_cast (temp)); - else - return this->read_4 (reinterpret_cast (temp)); - } - - return (this->good_bit_ = false); -} - -ACE_CDR::Boolean -ACE_InputCDR::read_wchar (ACE_CDR::WChar& x) -{ - if (this->wchar_translator_ != 0) - { - this->good_bit_ = this->wchar_translator_->read_wchar (*this,x); - return this->good_bit_; - } - if (ACE_OutputCDR::wchar_maxbytes_ == 0) - { - errno = EACCES; - return (this->good_bit_ = false); - } - - if (ACE_OutputCDR::wchar_maxbytes_ == sizeof (ACE_CDR::WChar)) - { - if (static_cast (major_version_) == 1 - && static_cast (minor_version_) == 2) - { - ACE_CDR::Octet len; - - if (this->read_1 (&len)) - return this->read_array - (reinterpret_cast (&x), - static_cast (len), - ACE_CDR::OCTET_ALIGN, - 1); - - else - return (this->good_bit_ = false); - } - - void * const temp = &x; - if (sizeof (ACE_CDR::WChar) == 2) - return this->read_2 (reinterpret_cast (temp)); - else - return this->read_4 (reinterpret_cast (temp)); - } - - if (static_cast (major_version_) == 1 - && static_cast (minor_version_) == 2) - { - ACE_CDR::Octet len; - - if (this->read_1 (&len)) - { - if (len == 2) - { - ACE_CDR::Short sx; - if (this->read_array - (reinterpret_cast (&sx), - static_cast (len), - ACE_CDR::OCTET_ALIGN, - 1)) - { - x = static_cast (sx); - return true; - } - } - else - { - ACE_CDR::Octet ox; - if (this->read_array - (reinterpret_cast (&ox), - static_cast (len), - ACE_CDR::OCTET_ALIGN, - 1)) - { - x = static_cast (ox); - return true; - } - } - } - } - else - { - if (ACE_OutputCDR::wchar_maxbytes_ == 2) - { - ACE_CDR::UShort sx; - if (this->read_2 (reinterpret_cast (&sx))) - { - x = static_cast (sx); - return true; - } - } - else - { - ACE_CDR::Octet ox; - if (this->read_1 (&ox)) - { - x = static_cast (ox); - return true; - } - - } - } - return (this->good_bit_ = false); -} - -ACE_CDR::Boolean -ACE_InputCDR::read_string (ACE_CDR::Char *&x) -{ - // @@ This is a slight violation of "Optimize for the common case", - // i.e. normally the translator will be 0, but OTOH the code is - // smaller and should be better for the cache ;-) ;-) - if (this->char_translator_ != 0) - { - this->good_bit_ = this->char_translator_->read_string (*this, x); - return this->good_bit_; - } - - ACE_CDR::ULong len = 0; - - if (!this->read_ulong (len)) - return false; - - // A check for the length being too great is done later in the - // call to read_char_array but we want to have it done before - // the memory is allocated. - if (len > 0 && len <= this->length()) - { -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (x, - static_cast (ACE_Allocator::instance()->malloc(sizeof (ACE_CDR::Char) * (len))), - 0); -#else - ACE_NEW_RETURN (x, - ACE_CDR::Char[len], - 0); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - ACE_Auto_Basic_Array_Ptr safe_data (x); - - if (this->read_char_array (x, len)) - { - (void) safe_data.release (); - return true; - } - } - else if (len == 0) - { - // Convert any null strings to empty strings since empty - // strings can cause crashes. (See bug 58.) -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (x, - static_cast (ACE_Allocator::instance()->malloc(sizeof (ACE_CDR::Char) * (1))), - 0); -#else - ACE_NEW_RETURN (x, - ACE_CDR::Char[1], - 0); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - ACE_OS::strcpy (const_cast (x), ""); - return true; - } - - x = 0; - return (this->good_bit_ = false); -} - -ACE_CDR::Boolean -ACE_InputCDR::read_string (ACE_CString &x) -{ - ACE_CDR::Char * data = 0; - if (this->read_string (data)) - { - ACE_Auto_Basic_Array_Ptr safe_data (data); - x = data; - return true; - } - - x = ""; - return (this->good_bit_ = false); -} - -ACE_CDR::Boolean -ACE_InputCDR::read_wstring (ACE_CDR::WChar*& x) -{ - // @@ This is a slight violation of "Optimize for the common case", - // i.e. normally the translator will be 0, but OTOH the code is - // smaller and should be better for the cache ;-) ;-) - if (this->wchar_translator_ != 0) - { - this->good_bit_ = this->wchar_translator_->read_wstring (*this, x); - return this->good_bit_; - } - if (ACE_OutputCDR::wchar_maxbytes_ == 0) - { - errno = EACCES; - return (this->good_bit_ = false); - } - - ACE_CDR::ULong len = 0; - - if (!this->read_ulong (len)) - { - return false; - } - - // A check for the length being too great is done later in the - // call to read_char_array but we want to have it done before - // the memory is allocated. - if (len > 0 && len <= this->length ()) - { - ACE_Auto_Basic_Array_Ptr safe_data; - - if (static_cast (this->major_version_) == 1 - && static_cast (this->minor_version_) == 2) - { - len /= - ACE_Utils::truncate_cast ( - ACE_OutputCDR::wchar_maxbytes_); - - //allocating one extra for the null character needed by applications -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (x, - static_cast (ACE_Allocator::instance()->malloc(sizeof (ACE_CDR::WChar) * (len + 1))), - 0); -#else - ACE_NEW_RETURN (x, - ACE_CDR::WChar [len + 1], - false); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - ACE_auto_ptr_reset (safe_data, x); - - if (this->read_wchar_array (x, len)) - { - - //Null character used by applications to find the end of - //the wstring - //Is this okay with the GIOP 1.2 spec?? - x[len] = '\x00'; - - (void) safe_data.release (); - - return true; - } - } - else - { -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (x, - static_cast (ACE_Allocator::instance()->malloc(sizeof (ACE_CDR::WChar) * (len))), - 0); -#else - ACE_NEW_RETURN (x, - ACE_CDR::WChar [len], - false); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - ACE_auto_ptr_reset (safe_data, x); - - if (this->read_wchar_array (x, len)) - { - (void) safe_data.release (); - - return true; - } - } - } - else if (len == 0) - { - // Convert any null strings to empty strings since empty - // strings can cause crashes. (See bug 58.) -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (x, - static_cast (ACE_Allocator::instance()->malloc(sizeof (ACE_CDR::WChar) * (1))), - 0); -#else - ACE_NEW_RETURN (x, - ACE_CDR::WChar [1], - false); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - x[0] = '\x00'; - return true; - } - - this->good_bit_ = false; - x = 0; - return false; -} - -// As of C++11 std::string guarantees contiguous memory storage. -// That provides the opportunity to optimize CDR streaming. -ACE_CDR::Boolean -ACE_InputCDR::read_string (std::string& x) -{ -#if defined (ACE_HAS_CPP11) - // @@ This is a slight violation of "Optimize for the common case", - // i.e. normally the translator will be 0, but OTOH the code is - // smaller and should be better for the cache ;-) ;-) - if (this->char_translator_ != 0) - { - this->good_bit_ = this->char_translator_->read_string (*this, x); - return this->good_bit_; - } - - ACE_CDR::ULong len = 0; - - if (!this->read_ulong (len)) - return false; - - // A check for the length being too great is done later in the - // call to read_char_array but we want to have it done before - // the memory is allocated. - if (len > 0 && len <= this->length()) - { - try - { - x.resize (len-1); // no need to include the terminating '\0' here - } - catch (const std::bad_alloc&) - { - return false; - } - - if (len == 0 || this->read_char_array (&x[0], len-1)) - { - return this->skip_char (); // skip the terminating '\0' - } - } - - this->good_bit_ = false; - x.clear (); - return false; -#else - ACE_CDR::Char *buf = 0; - ACE_CDR::Boolean const marshal_flag = this->read_string (buf); - x.assign (buf); - ACE::strdelete (buf); - return marshal_flag; -#endif -} - -#if !defined(ACE_LACKS_STD_WSTRING) -ACE_CDR::Boolean -ACE_InputCDR::read_wstring (std::wstring& x) -{ -#if defined (ACE_HAS_CPP11) - // @@ This is a slight violation of "Optimize for the common case", - // i.e. normally the translator will be 0, but OTOH the code is - // smaller and should be better for the cache ;-) ;-) - if (this->wchar_translator_ != 0) - { - this->good_bit_ = this->wchar_translator_->read_wstring (*this, x); - return this->good_bit_; - } - if (ACE_OutputCDR::wchar_maxbytes_ == 0) - { - errno = EACCES; - return (this->good_bit_ = false); - } - - ACE_CDR::ULong len = 0; - - if (!this->read_ulong (len)) - { - return false; - } - - // A check for the length being too great is done later in the - // call to read_char_array but we want to have it done before - // the memory is allocated. - if (len > 0 && len <= this->length ()) - { - if (static_cast (this->major_version_) == 1 - && static_cast (this->minor_version_) == 2) - { - len /= - ACE_Utils::truncate_cast ( - ACE_OutputCDR::wchar_maxbytes_); - - try - { - x.resize (len); - } - catch (const std::bad_alloc&) - { - return false; - } - - if (this->read_wchar_array (&x[0], len)) - { - return true; - } - } - else - { - try - { - x.resize (len-1); // no need to include the terminating '\0' here - } - catch (const std::bad_alloc&) - { - return false; - } - - if (len == 1 || this->read_wchar_array (&x[0], len-1)) - { - return this->skip_wchar (); // skip the terminating '\0' - } - } - } - else if (len == 0) - { - x.clear (); - return true; - } - - this->good_bit_ = false; - x.clear (); - return false; -#else - ACE_CDR::WChar *buf = 0; - ACE_CDR::Boolean const marshal_flag = this->read_wstring (buf); - x.assign (buf); - ACE::strdelete (buf); - return marshal_flag; -#endif -} -#endif - -ACE_CDR::Boolean -ACE_InputCDR::read_array (void* x, - size_t size, - size_t align, - ACE_CDR::ULong length) -{ - if (length == 0) - return true; - char* buf = 0; - - if (this->adjust (size * length, align, buf) == 0) - { -#if defined (ACE_DISABLE_SWAP_ON_READ) - ACE_OS::memcpy (x, buf, size*length); -#else - if (!this->do_byte_swap_ || size == 1) - ACE_OS::memcpy (x, buf, size*length); - else - { - char *target = reinterpret_cast (x); - switch (size) - { - case 2: - ACE_CDR::swap_2_array (buf, target, length); - break; - case 4: - ACE_CDR::swap_4_array (buf, target, length); - break; - case 8: - ACE_CDR::swap_8_array (buf, target, length); - break; - case 16: - ACE_CDR::swap_16_array (buf, target, length); - break; - default: - // TODO: print something? - this->good_bit_ = false; - return false; - } - } -#endif /* ACE_DISABLE_SWAP_ON_READ */ - return this->good_bit_; - } - return false; -} - -ACE_CDR::Boolean -ACE_InputCDR::read_wchar_array_i (ACE_CDR::WChar* x, - ACE_CDR::ULong length) -{ - if (length == 0) - return true; - char* buf = 0; - size_t const align = (ACE_OutputCDR::wchar_maxbytes_ == 2) ? - ACE_CDR::SHORT_ALIGN : - ACE_CDR::OCTET_ALIGN; - - if (this->adjust (ACE_OutputCDR::wchar_maxbytes_ * length, align, buf) == 0) - { - if (ACE_OutputCDR::wchar_maxbytes_ == 2) - { - ACE_CDR::UShort *sb = reinterpret_cast (buf); - for (size_t i = 0; i < length; ++i) -#if defined (ACE_DISABLE_SWAP_ON_READ) - x[i] = static_cast (sb[i]); -#else - if (!this->do_byte_swap_) - x[i] = static_cast (sb[i]); - else - { - ACE_CDR::UShort sx; - ACE_CDR::swap_2 (&buf[i * 2], reinterpret_cast (&sx)); - x[i] = static_cast (sx); - } -#endif /* ACE_DISABLE_SWAP_ON_READ */ - } - else - { - for (size_t i = 0; i < length; ++i) - x[i] = static_cast (buf[i]); - } - return this->good_bit_; - } - return false; -} - - -ACE_CDR::Boolean -ACE_InputCDR::read_boolean_array (ACE_CDR::Boolean *x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length > this->length ()) - { - this->good_bit_ = false; - return false; - } - - // It is hard to optimize this, the spec requires that on the wire - // booleans be represented as a byte with value 0 or 1, but in - // memory it is possible (though very unlikely) that a boolean has - // a non-zero value (different from 1). - // We resort to a simple loop. - for (ACE_CDR::ULong i = 0; i != length && this->good_bit_; ++i) - (void) this->read_boolean (x[i]); - - return this->good_bit_; -} - -ACE_CDR::Boolean -ACE_InputCDR::read_1 (ACE_CDR::Octet *x) -{ - if (this->rd_ptr () < this->wr_ptr ()) - { - *x = *reinterpret_cast (this->rd_ptr ()); - this->start_.rd_ptr (1); - return true; - } - - this->good_bit_ = false; - return false; -} - -ACE_CDR::Boolean -ACE_InputCDR::read_2 (ACE_CDR::UShort *x) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::SHORT_SIZE, buf) == 0) - { -#if !defined (ACE_DISABLE_SWAP_ON_READ) - if (!this->do_byte_swap_) - *x = *reinterpret_cast (buf); - else - ACE_CDR::swap_2 (buf, reinterpret_cast (x)); -#else - *x = *reinterpret_cast (buf); -#endif /* ACE_DISABLE_SWAP_ON_READ */ - return true; - } - this->good_bit_ = false; - return false; -} - -ACE_CDR::Boolean -ACE_InputCDR::read_4 (ACE_CDR::ULong *x) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::LONG_SIZE, buf) == 0) - { -#if !defined (ACE_DISABLE_SWAP_ON_READ) - if (!this->do_byte_swap_) - *x = *reinterpret_cast (buf); - else - ACE_CDR::swap_4 (buf, reinterpret_cast (x)); -#else - *x = *reinterpret_cast (buf); -#endif /* ACE_DISABLE_SWAP_ON_READ */ - return true; - } - this->good_bit_ = false; - return false; -} - -ACE_CDR::Boolean -ACE_InputCDR::read_8 (ACE_CDR::ULongLong *x) -{ - char *buf = 0; - - if (this->adjust (ACE_CDR::LONGLONG_SIZE, buf) == 0) - { -#if !defined (ACE_DISABLE_SWAP_ON_READ) - if (!this->do_byte_swap_) - *x = *reinterpret_cast (buf); - else - ACE_CDR::swap_8 (buf, reinterpret_cast (x)); -#else - *x = *reinterpret_cast (buf); -#endif /* ACE_DISABLE_SWAP_ON_READ */ - return true; - } - - this->good_bit_ = false; - return false; -} - -ACE_CDR::Boolean -ACE_InputCDR::read_16 (ACE_CDR::LongDouble *x) -{ - char *buf = 0; - if (this->adjust (ACE_CDR::LONGDOUBLE_SIZE, - ACE_CDR::LONGDOUBLE_ALIGN, - buf) == 0) - { -#if !defined (ACE_DISABLE_SWAP_ON_READ) - if (!this->do_byte_swap_) - *x = *reinterpret_cast (buf); - else - ACE_CDR::swap_16 (buf, reinterpret_cast (x)); -#else - *x = *reinterpret_cast (buf); -#endif /* ACE_DISABLE_SWAP_ON_READ */ - return true; - } - - this->good_bit_ = false; - return false; -} - -ACE_CDR::Boolean -ACE_InputCDR::skip_string (void) -{ - ACE_CDR::ULong len = 0; - if (this->read_ulong (len)) - { - if (static_cast (~0u) == len) - { - // Indirection, next Long in stream is signed offset to actual - // string location (backwards in same stream from here). - ACE_CDR::Long offset = 0; - if (this->read_long (offset)) - { - return true; - } - } - else if (this->rd_ptr () + len <= this->wr_ptr ()) - { - this->rd_ptr (len); - return true; - } - this->good_bit_ = false; - } - return false; -} - -ACE_CDR::Boolean -ACE_InputCDR::skip_wstring (void) -{ - ACE_CDR::ULong len = 0; - ACE_CDR::Boolean continue_skipping = read_ulong (len); - - if (continue_skipping && len != 0) - { - if (static_cast (this->major_version_) == 1 - && static_cast (this->minor_version_) == 2) - continue_skipping = this->skip_bytes ((size_t)len); - else - while (continue_skipping && len--) - continue_skipping = this->skip_wchar (); - } - return continue_skipping; -} - -ACE_CDR::Boolean -ACE_InputCDR::skip_bytes (size_t len) -{ - if (this->rd_ptr () + len <= this->wr_ptr ()) - { - this->rd_ptr (len); - return true; - } - this->good_bit_ = false; - return false; -} - -int -ACE_InputCDR::grow (size_t newsize) -{ - if (ACE_CDR::grow (&this->start_, newsize) == -1) - return -1; - - ACE_CDR::mb_align (&this->start_); - this->start_.wr_ptr (newsize); - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - if (newsize > this->start_.total_size ()) - { - this->monitor_->receive (newsize); - } -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - - return 0; -} - -void -ACE_InputCDR::reset (const ACE_Message_Block* data, - int byte_order) -{ - this->reset_byte_order (byte_order); - ACE_CDR::consolidate (&this->start_, data); - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -void -ACE_InputCDR::steal_from (ACE_InputCDR &cdr) -{ - this->do_byte_swap_ = cdr.do_byte_swap_; - this->start_.data_block (cdr.start_.data_block ()->duplicate ()); - - // If the message block had a DONT_DELETE flags, just clear it off.. - this->start_.clr_self_flags (ACE_Message_Block::DONT_DELETE); - this->start_.rd_ptr (cdr.start_.rd_ptr ()); - - this->start_.wr_ptr (cdr.start_.wr_ptr ()); - this->major_version_ = cdr.major_version_; - this->minor_version_ = cdr.minor_version_; - cdr.reset_contents (); - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -void -ACE_InputCDR::exchange_data_blocks (ACE_InputCDR &cdr) -{ - // Exchange byte orders - int const byte_order = cdr.do_byte_swap_; - cdr.do_byte_swap_ = this->do_byte_swap_; - this->do_byte_swap_ = byte_order; - - // Get the destination read and write pointers - size_t const drd_pos = - cdr.start_.rd_ptr () - cdr.start_.base (); - size_t const dwr_pos = - cdr.start_.wr_ptr () - cdr.start_.base (); - - // Get the source read & write pointers - size_t const srd_pos = - this->start_.rd_ptr () - this->start_.base (); - size_t const swr_pos = - this->start_.wr_ptr () - this->start_.base (); - - // Exchange data_blocks. Dont release any of the data blocks. - ACE_Data_Block *dnb = - this->start_.replace_data_block (cdr.start_.data_block ()); - cdr.start_.replace_data_block (dnb); - - // Exchange the flags information.. - ACE_Message_Block::Message_Flags df = cdr.start_.self_flags (); - ACE_Message_Block::Message_Flags sf = this->start_.self_flags (); - - cdr.start_.clr_self_flags (df); - this->start_.clr_self_flags (sf); - - cdr.start_.set_self_flags (sf); - this->start_.set_self_flags (df); - - // Reset the pointers to zero before it is set again. - cdr.start_.reset (); - this->start_.reset (); - - // Set the read and write pointers. - if (cdr.start_.size () >= srd_pos) - { - cdr.start_.rd_ptr (srd_pos); - } - - if (cdr.start_.size () >= swr_pos) - { - cdr.start_.wr_ptr (swr_pos); - } - - if (this->start_.size () >= drd_pos) - { - this->start_.rd_ptr (drd_pos); - } - - if (this->start_.size () >= dwr_pos) - { - this->start_.wr_ptr (dwr_pos); - } - - ACE_CDR::Octet const dmajor = cdr.major_version_; - ACE_CDR::Octet const dminor = cdr.minor_version_; - - // Exchange the GIOP version info - cdr.major_version_ = this->major_version_; - cdr.minor_version_ = this->minor_version_; - - this->major_version_ = dmajor; - this->minor_version_ = dminor; - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_Data_Block * -ACE_InputCDR::clone_from (ACE_InputCDR &cdr) -{ - this->do_byte_swap_ = cdr.do_byte_swap_; - - // Get the read & write pointer positions in the incoming CDR - // streams - char *rd_ptr = cdr.start_.rd_ptr (); - char *wr_ptr = cdr.start_.wr_ptr (); - - // Now reset the incoming CDR stream - cdr.start_.reset (); - - // As we have reset the stream, try to align the underlying message - // block in the incoming stream - ACE_CDR::mb_align (&cdr.start_); - - // Get the read & write pointer positions again - char *nrd_ptr = cdr.start_.rd_ptr (); - char *nwr_ptr = cdr.start_.wr_ptr (); - - // Actual length of the stream is.. - // @todo: This will look idiotic, but we dont seem to have much of a - // choice. How do we calculate the length of the incoming stream? - // Calling the method before calling reset () would give us the - // wrong length of the stream that needs copying. So we do the - // calulation like this - // (1) We get the and positions of the incoming - // stream. - // (2) Then we reset the stream and then align it. - // (3) We get the and positions again. (Points #1 - // thru #3 has been done already) - // (4) The difference in the and positions gives - // us the following, the actual bytes traversed by the and - // . - // (5) The bytes traversed by the is the actual length of - // the stream. - - // Actual bytes traversed - size_t rd_bytes = rd_ptr - nrd_ptr; - size_t wr_bytes = wr_ptr - nwr_ptr; - - ACE_CDR::mb_align (&this->start_); - - ACE_Data_Block *db = this->start_.data_block (); - - // If the size of the data that needs to be copied are higher than - // what is available, then do a reallocation. - if (wr_bytes > (this->start_.size () - ACE_CDR::MAX_ALIGNMENT)) - { - // @@NOTE: We need to probably add another method to the message - // block interface to simplify this - db = cdr.start_.data_block ()->clone_nocopy (); - - if (db == 0 || db->size ((wr_bytes) + - ACE_CDR::MAX_ALIGNMENT) == -1) - return 0; - - // Replace our data block by using the incoming CDR stream. - db = this->start_.replace_data_block (db); - - // Align the start_ message block. - ACE_CDR::mb_align (&this->start_); - - // Clear the DONT_DELETE flag if it has been set - this->start_.clr_self_flags (ACE_Message_Block::DONT_DELETE); - } - - // Now do the copy - (void) ACE_OS::memcpy (this->start_.wr_ptr (), - cdr.start_.rd_ptr (), - wr_bytes); - - // Set the read pointer position to the same point as that was in - // cdr. - this->start_.rd_ptr (rd_bytes); - this->start_.wr_ptr (wr_bytes); - - // We have changed the read & write pointers for the incoming - // stream. Set them back to the positions that they were before.. - cdr.start_.rd_ptr (rd_bytes); - cdr.start_.wr_ptr (wr_bytes); - - this->major_version_ = cdr.major_version_; - this->minor_version_ = cdr.minor_version_; - - // Copy the char/wchar translators - this->char_translator_ = cdr.char_translator_; - this->wchar_translator_ = cdr.wchar_translator_; - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - - return db; -} - -ACE_Message_Block* -ACE_InputCDR::steal_contents (void) -{ - ACE_Message_Block* block = this->start_.clone (); - this->start_.data_block (block->data_block ()->clone ()); - - // If at all our message had a DONT_DELETE flag set, just clear it - // off. - this->start_.clr_self_flags (ACE_Message_Block::DONT_DELETE); - - ACE_CDR::mb_align (&this->start_); - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - - return block; -} - -void -ACE_InputCDR::reset_contents (void) -{ - this->start_.data_block (this->start_.data_block ()->clone_nocopy ()); - - // Reset the flags... - this->start_.clr_self_flags (ACE_Message_Block::DONT_DELETE); - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - -void -ACE_InputCDR::register_monitor (const char *id) -{ - this->monitor_->name (id); - this->monitor_->add_to_registry (); -} - -void -ACE_InputCDR::unregister_monitor (void) -{ - this->monitor_->remove_from_registry (); -} - -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - -// -------------------------------------------------------------- - -ACE_Char_Codeset_Translator::~ACE_Char_Codeset_Translator (void) -{ -} - -ACE_CDR::Boolean -ACE_Char_Codeset_Translator::read_string (ACE_InputCDR &cdr, - std::string &x) -{ - ACE_CDR::Char *buf = 0; - ACE_CDR::Boolean const marshal_flag = this->read_string (cdr, buf); - x.assign (buf); - ACE::strdelete (buf); - return marshal_flag; -} - -// -------------------------------------------------------------- - -ACE_WChar_Codeset_Translator::~ACE_WChar_Codeset_Translator (void) -{ -} - -#if !defined(ACE_LACKS_STD_WSTRING) -ACE_CDR::Boolean -ACE_WChar_Codeset_Translator::read_wstring (ACE_InputCDR &cdr, - std::wstring &x) -{ - ACE_CDR::WChar *buf = 0; - ACE_CDR::Boolean const marshal_flag = this->read_wstring (cdr, buf); - x.assign (buf); - ACE::strdelete (buf); - return marshal_flag; -} -#endif - -// -------------------------------------------------------------- - -ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, const ACE_CString &x) -{ - os.write_string (x); - return os.good_bit (); -} - -ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_CString &x) -{ - is.read_string (x); - return is.good_bit (); -} - -#if defined (GEN_OSTREAM_OPS) - -std::ostream& -operator<< (std::ostream &os, ACE_OutputCDR::from_boolean x) -{ - return (x.val_ ? os << "true" : os << "false"); -} - -std::ostream& -operator<< (std::ostream &os, ACE_OutputCDR::from_char x) -{ - return os << '\'' << x.val_ << '\''; -} - -std::ostream& -operator<< (std::ostream &os, ACE_OutputCDR::from_wchar x) -{ - os.setf (ios_base::showbase); - os.setf (ios_base::hex, ios_base::basefield); - os << x.val_; - os.unsetf (ios_base::showbase); - os.setf (ios_base::dec, ios_base::basefield); - return os; -} - -std::ostream& -operator<< (std::ostream &os, ACE_OutputCDR::from_octet x) -{ - // Same format (hex) and no risk of overflow. - ACE_CDR::WChar w = static_cast (x.val_); - ACE_OutputCDR::from_wchar tmp (w); - return os << tmp; -} - -#endif /* GEN_OSTREAM_OPS */ - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/CDR_Stream.h b/deps/acelite/ace/CDR_Stream.h deleted file mode 100644 index 4ce2402a5..000000000 --- a/deps/acelite/ace/CDR_Stream.h +++ /dev/null @@ -1,1501 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file CDR_Stream.h - * - * ACE Common Data Representation (CDR) marshaling and demarshaling - * classes. - * - * This implementation was inspired in the CDR class in SunSoft's - * IIOP engine, but has a completely different implementation and a - * different interface too. - * - * The current implementation assumes that the host has 1-byte, - * 2-byte and 4-byte integral types, and that it has single - * precision and double precision IEEE floats. - * Those assumptions are pretty good these days, with Crays being - * the only known exception. - * - * Optimizations - * ------------- - * ACE_LACKS_CDR_ALIGNMENT - * @author Arvind S. Krishna - * - * CDR stream ignores alignment when marshaling data. Use this option - * only when ACE_DISABLE_SWAP_ON_READ can be enabled. This option requires - * ACE CDR engine to do both marshaling and demarshaling. - * - * @author TAO version by Aniruddha Gokhale - * @author Carlos O'Ryan - * @author ACE version by Jeff Parsons - * @author Istvan Buki - * @author Codeset translation by Jim Rogers - */ -//============================================================================= - -#ifndef ACE_CDR_STREAM_H -#define ACE_CDR_STREAM_H - -#include /**/ "ace/pre.h" - -#include "ace/CDR_Base.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/SStringfwd.h" -#include "ace/Message_Block.h" - -#if defined (GEN_OSTREAM_OPS) -#include "ace/streams.h" -#endif /* GEN_OSTREAM_OPS */ - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) -#include "Monitor_Size.h" -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - -#include - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Char_Codeset_Translator; -class ACE_WChar_Codeset_Translator; - -class ACE_InputCDR; - -/** - * @class ACE_OutputCDR - * - * @brief A CDR stream for marshalling data, most often for transmission to - * another system which may or may not have the same byte order. - * - * This class is based on the the CORBA spec for Java (98-02-29), - * java class omg.org.CORBA.portable.OutputStream. It diverts in - * a few ways: - * @li Operations taking arrays don't have offsets, because in C++ - * it is easier to describe an array starting from x+offset. - * @li Operations return an error status, because exceptions are - * not widely available in C++ (yet). - */ -class ACE_Export ACE_OutputCDR -{ -public: - /** - * The Codeset translators need access to some private members to - * efficiently marshal arrays - * For reading from an output CDR stream. - */ - friend class ACE_Char_Codeset_Translator; - friend class ACE_WChar_Codeset_Translator; - friend class ACE_InputCDR; - - /** - * Default constructor; allows one to set byte ordering, allocators, and - * tuning information. - * - * @param size Causes constructor to preallocate @a size bytes; if - * @a size is 0 it allocates the default size. - * - * @param byte_order The byte order that data will have within this - * object. Unless otherwise specified, the byte order - * will be the order native to the hardware this is - * executed on. To force the marshalled data to have - * a specific order, specify one of the values defined - * in ACE_CDR::Byte_Order. - * @note The @c ACE_ENABLE_SWAP_ON_WRITE config macro - * must be set for any local byte swapping to occur - * as data is inserted into an ACE_OutputCDR object. - */ - ACE_OutputCDR (size_t size = 0, - int byte_order = ACE_CDR::BYTE_ORDER_NATIVE, - ACE_Allocator* buffer_allocator = 0, - ACE_Allocator* data_block_allocator = 0, - ACE_Allocator* message_block_allocator = 0, - size_t memcpy_tradeoff = ACE_DEFAULT_CDR_MEMCPY_TRADEOFF, - ACE_CDR::Octet major_version = ACE_CDR_GIOP_MAJOR_VERSION, - ACE_CDR::Octet minor_version = ACE_CDR_GIOP_MINOR_VERSION); - - /// Build a CDR stream with an initial buffer, it will *not* remove - /// @a data, since it did not allocated it. It's important to be careful - /// with the alignment of @a data. - /** - * Create an output stream from an arbitrary buffer, care must be - * exercised with alignment, because this constructor will align if - * needed. In this case @a data will not point to the start of the - * output stream. @c begin()->rd_ptr() points to the start of the - * output stream. See @c ACE_ptr_align_binary() to properly align a - * pointer and use ACE_CDR::MAX_ALIGNMENT for the correct alignment. - */ - ACE_OutputCDR (char *data, - size_t size, - int byte_order = ACE_CDR::BYTE_ORDER_NATIVE, - ACE_Allocator* buffer_allocator = 0, - ACE_Allocator* data_block_allocator = 0, - ACE_Allocator* message_block_allocator = 0, - size_t memcpy_tradeoff = ACE_DEFAULT_CDR_MEMCPY_TRADEOFF, - ACE_CDR::Octet giop_major_version = ACE_CDR_GIOP_MAJOR_VERSION, - ACE_CDR::Octet giop_minor_version = ACE_CDR_GIOP_MINOR_VERSION); - - /// Build a CDR stream with an initial data block, it will *not* remove - /// @a data_block, since it did not allocated it. It's important to be - /// careful with the alignment of @a data_block. - /** - * Create an output stream from an arbitrary data block, care must be - * exercised with alignment, because this constructor will align if - * needed. In this case @a data_block will not point to the - * start of the output stream. begin()->rd_ptr() points to the start - * off the output stream. See ACE_ptr_align_binary() to properly align a - * pointer and use ACE_CDR::MAX_ALIGNMENT for the correct alignment. - */ - ACE_OutputCDR (ACE_Data_Block *data_block, - int byte_order = ACE_CDR::BYTE_ORDER_NATIVE, - ACE_Allocator* message_block_allocator = 0, - size_t memcpy_tradeoff = ACE_DEFAULT_CDR_MEMCPY_TRADEOFF, - ACE_CDR::Octet giop_major_version = ACE_CDR_GIOP_MAJOR_VERSION, - ACE_CDR::Octet giop_minor_version = ACE_CDR_GIOP_MINOR_VERSION); - - /// Build a CDR stream with an initial Message_Block chain, it will - /// *not* remove @a data, since it did not allocate it. - ACE_OutputCDR (ACE_Message_Block *data, - int byte_order = ACE_CDR::BYTE_ORDER_NATIVE, - size_t memcpy_tradeoff = ACE_DEFAULT_CDR_MEMCPY_TRADEOFF, - ACE_CDR::Octet giop_major_version = ACE_CDR_GIOP_MAJOR_VERSION, - ACE_CDR::Octet giop_minor_version = ACE_CDR_GIOP_MINOR_VERSION); - - /// destructor - ~ACE_OutputCDR (void); - - /** - * Disambiguate overload when inserting booleans, octets, chars, and - * bounded strings. - */ - //@{ @name Helper classes - - struct ACE_Export from_boolean - { - explicit from_boolean (ACE_CDR::Boolean b); - ACE_CDR::Boolean val_; - }; - - struct ACE_Export from_octet - { - explicit from_octet (ACE_CDR::Octet o); - ACE_CDR::Octet val_; - }; - - struct ACE_Export from_char - { - explicit from_char (ACE_CDR::Char c); - ACE_CDR::Char val_; - }; - - struct ACE_Export from_wchar - { - explicit from_wchar (ACE_CDR::WChar wc); - ACE_CDR::WChar val_; - }; - - struct ACE_Export from_string - { - from_string (ACE_CDR::Char* s, - ACE_CDR::ULong b, - ACE_CDR::Boolean nocopy = 0); - from_string (const ACE_CDR::Char* s, - ACE_CDR::ULong b, - ACE_CDR::Boolean nocopy = 0); - ACE_CDR::Char *val_; - ACE_CDR::ULong bound_; - ACE_CDR::Boolean nocopy_; - }; - - struct ACE_Export from_wstring - { - from_wstring (ACE_CDR::WChar* ws, - ACE_CDR::ULong b, - ACE_CDR::Boolean nocopy = 0); - from_wstring (const ACE_CDR::WChar* ws, - ACE_CDR::ULong b, - ACE_CDR::Boolean nocopy = 0); - ACE_CDR::WChar *val_; - ACE_CDR::ULong bound_; - ACE_CDR::Boolean nocopy_; - }; - - struct ACE_Export from_std_string - { - from_std_string (const std::string &s, - ACE_CDR::ULong b); - const std::string &val_; - ACE_CDR::ULong bound_; - }; - -#if !defined(ACE_LACKS_STD_WSTRING) - struct ACE_Export from_std_wstring - { - from_std_wstring (const std::wstring &ws, - ACE_CDR::ULong b); - const std::wstring &val_; - ACE_CDR::ULong bound_; - }; -#endif - //@} - - /** - * @{ @name Write operations - * Return 0 on failure and 1 on success. - */ - ACE_CDR::Boolean write_boolean (ACE_CDR::Boolean x); - ACE_CDR::Boolean write_char (ACE_CDR::Char x); - ACE_CDR::Boolean write_wchar (ACE_CDR::WChar x); - ACE_CDR::Boolean write_octet (ACE_CDR::Octet x); - ACE_CDR::Boolean write_short (ACE_CDR::Short x); - ACE_CDR::Boolean write_ushort (ACE_CDR::UShort x); - ACE_CDR::Boolean write_long (ACE_CDR::Long x); - ACE_CDR::Boolean write_ulong (ACE_CDR::ULong x); - ACE_CDR::Boolean write_longlong (const ACE_CDR::LongLong &x); - ACE_CDR::Boolean write_ulonglong (const ACE_CDR::ULongLong &x); - ACE_CDR::Boolean write_float (ACE_CDR::Float x); - ACE_CDR::Boolean write_double (const ACE_CDR::Double &x); - ACE_CDR::Boolean write_longdouble (const ACE_CDR::LongDouble &x); - ACE_CDR::Boolean write_fixed (const ACE_CDR::Fixed &x); - - /// For string we offer methods that accept a precomputed length. - ACE_CDR::Boolean write_string (const ACE_CDR::Char *x); - ACE_CDR::Boolean write_string (ACE_CDR::ULong len, - const ACE_CDR::Char *x); - ACE_CDR::Boolean write_string (const ACE_CString &x); - ACE_CDR::Boolean write_wstring (const ACE_CDR::WChar *x); - ACE_CDR::Boolean write_wstring (ACE_CDR::ULong length, - const ACE_CDR::WChar *x); - ACE_CDR::Boolean write_string (const std::string &x); -#if !defined(ACE_LACKS_STD_WSTRING) - ACE_CDR::Boolean write_wstring (const std::wstring &x); -#endif - - //@} - - /// @note the portion written starts at @a x and ends - /// at @a x + @a length. - /// The length is *NOT* stored into the CDR stream. - //@{ @name Array write operations - ACE_CDR::Boolean write_boolean_array (const ACE_CDR::Boolean *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_char_array (const ACE_CDR::Char *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_wchar_array (const ACE_CDR::WChar* x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_octet_array (const ACE_CDR::Octet* x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_short_array (const ACE_CDR::Short *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_ushort_array (const ACE_CDR::UShort *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_long_array (const ACE_CDR::Long *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_ulong_array (const ACE_CDR::ULong *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_longlong_array (const ACE_CDR::LongLong* x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_ulonglong_array (const ACE_CDR::ULongLong *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_float_array (const ACE_CDR::Float *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_double_array (const ACE_CDR::Double *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean write_longdouble_array (const ACE_CDR::LongDouble* x, - ACE_CDR::ULong length); - - /// Write an octet array contained inside a MB, this can be optimized - /// to minimize copies. - ACE_CDR::Boolean write_octet_array_mb (const ACE_Message_Block* mb); - //@} - - /** - * @{ @name Placeholder/replace operations - * Facilitates writing a placeholder into a CDR stream to be replaced - * later with a different value. - * - * @note An example use for this facility is: - * @code - ACE_OutputCDR strm; - ... // insert values... - char *pos = strm.write_long_placeholder (); - ... // insert more values - ACE_CDR::Long real_val; // Somehow assign the "correct" value - strm.replace (real_val, pos); // Replace earlier placeholder - @endcode - */ - - /** - * Write a placeholder into the stream. The placeholder's pointer - * is returned so it may later be passed as the @a loc argument to - * replace (). - * These methods align the stream's write pointer properly prior to - * writing the placeholder. - * - * @retval Pointer to the placeholder; 0 if there is not enough space - * in the stream and memory could not be allocated. - */ - char* write_long_placeholder (void); - char* write_short_placeholder (void); - char* write_boolean_placeholder (void); - char* write_char_placeholder (void); - char* write_longlong_placeholder (void); - char* write_octet_placeholder (void); - char* write_float_placeholder (void); - char* write_double_placeholder (void); - - /** - * Writes a new value into a specific location. This is commonly - * used to update a prior "placeholder" location in the stream. - * The specified location is assumed to have proper CDR alignment for the - * type to insert. This requirement is satisfied by using one of the - * placeholder-writing methods to align the stream for the anticipated - * value and obtain the correct location. - * Treatment of @a x with respect to byte swapping is the same as for when - * any value is inserted. - * - * @param x The value to insert into the specified location. - * @param loc The location at which to insert @a x. @a loc must be a valid - * position within the stream's current set of message blocks. - * - * @sa write_long_placeholder(), write_short_placeholder () - */ - ACE_CDR::Boolean replace (ACE_CDR::Long x, char* loc); - ACE_CDR::Boolean replace (ACE_CDR::ULong x, char* loc); - ACE_CDR::Boolean replace (ACE_CDR::Short x, char* loc); - ACE_CDR::Boolean replace (ACE_CDR::UShort x, char* loc); - ACE_CDR::Boolean replace (ACE_CDR::Boolean x, char* loc); - ACE_CDR::Boolean replace (ACE_CDR::Char x, char* loc); - ACE_CDR::Boolean replace (ACE_CDR::LongLong x, char* loc); - ACE_CDR::Boolean replace (ACE_CDR::ULongLong x, char* loc); - ACE_CDR::Boolean replace (ACE_CDR::Octet x, char* loc); - ACE_CDR::Boolean replace (ACE_CDR::Float x, char* loc); - ACE_CDR::Boolean replace (ACE_CDR::Double x, char* loc); - //@} - - /** - * Return 0 on failure and 1 on success. - */ - //@{ @name Append contents of own CDR stream to another - ACE_CDR::Boolean append_boolean (ACE_InputCDR &); - ACE_CDR::Boolean append_char (ACE_InputCDR &); - ACE_CDR::Boolean append_wchar (ACE_InputCDR &); - ACE_CDR::Boolean append_octet (ACE_InputCDR &); - ACE_CDR::Boolean append_short (ACE_InputCDR &); - ACE_CDR::Boolean append_ushort (ACE_InputCDR &); - ACE_CDR::Boolean append_long (ACE_InputCDR &); - ACE_CDR::Boolean append_ulong (ACE_InputCDR &); - ACE_CDR::Boolean append_longlong (ACE_InputCDR &); - ACE_CDR::Boolean append_ulonglong (ACE_InputCDR &); - ACE_CDR::Boolean append_float (ACE_InputCDR &); - ACE_CDR::Boolean append_double (ACE_InputCDR &); - ACE_CDR::Boolean append_longdouble (ACE_InputCDR &); - ACE_CDR::Boolean append_fixed (ACE_InputCDR &); - - ACE_CDR::Boolean append_wstring (ACE_InputCDR &); - ACE_CDR::Boolean append_string (ACE_InputCDR &); - //@} - - /// Returns @c false if an error has occurred. - /** - * @note The only expected error is to run out of memory. - */ - bool good_bit (void) const; - - /// Reuse the CDR stream to write on the old buffer. - void reset (void); - - /// Add the length of each message block in the chain. - size_t total_length (void) const; - - /** - * Return the start of the message block chain for this CDR stream. - * @note The complete CDR stream is represented by a chain of - * message blocks. - */ - const ACE_Message_Block *begin (void) const; - - /// Return the last message in the chain that is is use. - const ACE_Message_Block *end (void) const; - - /// Return the message block in chain. - const ACE_Message_Block *current (void) const; - - /// Replace the message block chain with a single message block. - /** - * Upon successful completion, there will be a single message block - * containing the data from the complete message block chain. - * - * @note The only expected error is to run out of memory. - */ - int consolidate (void); - - /** - * Access the underlying buffer (read only). @note This - * method only returns a pointer to the first block in the - * chain. - */ - const char *buffer (void) const; - - /** - * Return the size of first message block in the block chain. @note This - * method only returns information about the first block in the - * chain. - */ - size_t length (void) const; - - /** - * Utility function to allow the user more flexibility. - * Pads the stream up to the nearest @a alignment byte boundary. - * Argument MUST be a power of 2. - * Returns 0 on success and -1 on failure. - */ - int align_write_ptr (size_t alignment); - - /// Access the codeset translators. They can be null! - ACE_Char_Codeset_Translator *char_translator (void) const; - ACE_WChar_Codeset_Translator *wchar_translator (void) const; - - /// Set the char codeset translator. - void char_translator (ACE_Char_Codeset_Translator *); - /// Set the wchar codeset translator. - void wchar_translator (ACE_WChar_Codeset_Translator *); - - /// set the global size of serialized wchars. This may be different - /// than the size of a wchar_t. - static void wchar_maxbytes (size_t max_bytes); - - /// access the serialized size of wchars. - static size_t wchar_maxbytes (void); - - /** - * Return alignment of the wr_ptr(), with respect to the start of - * the CDR stream. This is not the same as the alignment of - * current->wr_ptr()! - */ - size_t current_alignment (void) const; - - void current_alignment (size_t current_alignment); - - /** - * Returns (in @a buf) the next position in the buffer aligned to - * @a size, it advances the Message_Block wr_ptr past the data - * (i.e., @a buf + @a size). If necessary it grows the Message_Block - * buffer. Sets the good_bit to false and returns a -1 on failure. - */ - int adjust (size_t size, - char *&buf); - - /// As above, but now the size and alignment requirements may be - /// different. - int adjust (size_t size, - size_t align, - char *&buf); - - /// Returns true if this stream is writing in non-native byte order - /// and false otherwise. For example, it would be true if either - /// ACE_ENABLE_SWAP_ON_WRITE is defined or a specific byte order was - /// specified for this stream. - bool do_byte_swap (void) const; - - /// Returns the byte order this stream is marshaling data in. Will be one - /// of the values in ACE_CDR::Byte_Order. - int byte_order (void) const; - - /// For use by a gateway, which creates the output stream for the - /// reply to the client in its native byte order, but which must - /// send the reply in the byte order of the target's reply to the - /// gateway. - void reset_byte_order (int byte_order); - - /// Set GIOP version info - void set_version (ACE_CDR::Octet major, ACE_CDR::Octet minor); - - /// Set the underlying GIOP version.. - void get_version (ACE_CDR::Octet &major, ACE_CDR::Octet &minor); - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - /// Register and unregister our buffer size monitor. - void register_monitor (const char* id); - void unregister_monitor (void); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - -private: - // Find the message block in the chain of message blocks - // that the provide location locates. - ACE_Message_Block* find (char* loc); - - /// disallow copying... - ACE_OutputCDR (const ACE_OutputCDR& rhs); - ACE_OutputCDR& operator= (const ACE_OutputCDR& rhs); - - ACE_CDR::Boolean write_1 (const ACE_CDR::Octet *x); - ACE_CDR::Boolean write_2 (const ACE_CDR::UShort *x); - ACE_CDR::Boolean write_4 (const ACE_CDR::ULong *x); - ACE_CDR::Boolean write_8 (const ACE_CDR::ULongLong *x); - ACE_CDR::Boolean write_16 (const ACE_CDR::LongDouble *x); - - /** - * write an array of @a length elements, each of @a size bytes and the - * start aligned at a multiple of @a align. The elements are assumed - * to be packed with the right alignment restrictions. It is mostly - * designed for buffers of the basic types. - * - * This operation uses @c memcpy; as explained above it is expected - * that using assignment is faster that @c memcpy for one element, - * but for several elements @c memcpy should be more efficient, it - * could be interesting to find the break even point and optimize - * for that case, but that would be too platform dependent. - */ - ACE_CDR::Boolean write_array (const void *x, - size_t size, - size_t align, - ACE_CDR::ULong length); - - - ACE_CDR::Boolean write_wchar_array_i (const ACE_CDR::WChar* x, - ACE_CDR::ULong length); - - - /** - * Grow the CDR stream. When it returns @a buf contains a pointer to - * memory in the CDR stream, with at least @a size bytes ahead of it - * and aligned to an @a align boundary. It moved the to . - */ - int grow_and_adjust (size_t size, - size_t align, - char *&buf); - -private: - /// The start of the chain of message blocks. - ACE_Message_Block start_; - - /// The current block in the chain where we are writing. - ACE_Message_Block *current_; - -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - /** - * The current alignment as measured from the start of the buffer. - * Usually this coincides with the alignment of the buffer in - * memory, but, when we chain another buffer this "quasi invariant" - * is broken. - * The current_alignment is used to readjust the buffer following - * the stolen message block. - */ - size_t current_alignment_; -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - - /** - * Is the current block writable. When we steal a buffer from the - * user and just chain it into the message block we are not supposed - * to write on it, even if it is past the start and end of the - * buffer. - */ - bool current_is_writable_; - - /** - * If not zero swap bytes at writing so the created CDR stream byte - * order does *not* match the machine byte order. The motivation - * for such a beast is that in some setting a few (fast) machines - * can be serving hundreds of slow machines with the opposite byte - * order, so it makes sense (as a load balancing device) to put the - * responsibility in the writers. - * - * @warning THIS IS NOT A STANDARD IN CORBA, USE AT YOUR OWN RISK - */ - bool do_byte_swap_; - - /// Set to false when an error ocurrs. - bool good_bit_; - - /// Break-even point for copying. - size_t const memcpy_tradeoff_; - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE::Monitor_Control::Size_Monitor *monitor_; -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - -protected: - /// GIOP version information - ACE_CDR::Octet major_version_; - ACE_CDR::Octet minor_version_; - - /// If not nil, invoke for translation of character and string data. - ACE_Char_Codeset_Translator *char_translator_; - ACE_WChar_Codeset_Translator *wchar_translator_; - - /** - * Some wide char codesets may be defined with a maximum number - * of bytes that is smaller than the size of a wchar_t. This means - * that the CDR cannot simply memcpy a block of wchars to and from - * the stream, but must instead realign the bytes appropriately. - * In cases when wchar i/o is not allowed, such as with GIOP 1.0, - * or not having a native wchar codeset defined, the maxbytes is - * set to zero, indicating no wchar data is allowed. - */ - static size_t wchar_maxbytes_; -}; - - -// **************************************************************** - -/** - * @class ACE_InputCDR - * - * @brief A CDR stream for demarshalling CDR-encoded data. - * - * This class is based on the the CORBA spec for Java (98-02-29), - * java class omg.org.CORBA.portable.InputStream. It diverts in a - * few ways: - * @li Operations to retrieve basic types take parameters by - * reference. - * @li Operations taking arrays don't have offsets, because in C++ - * it is easier to describe an array starting from x+offset. - * @li Operations return an error status, because exceptions are - * not widely available in C++ (yet). - */ -class ACE_Export ACE_InputCDR -{ -public: - // The translators need privileged access to efficiently demarshal - // arrays and such. - friend class ACE_Char_Codeset_Translator; - friend class ACE_WChar_Codeset_Translator; - - /** - * Create an input stream from an arbitrary buffer. The buffer must - * be properly aligned because this constructor will *not* work if - * the buffer is aligned unproperly.See ACE_ptr_align_binary() for - * instructions on how to align a pointer properly and use - * ACE_CDR::MAX_ALIGNMENT for the correct alignment. - */ - ACE_InputCDR (const char *buf, - size_t bufsiz, - int byte_order = ACE_CDR::BYTE_ORDER_NATIVE, - ACE_CDR::Octet major_version = ACE_CDR_GIOP_MAJOR_VERSION, - ACE_CDR::Octet minor_version = ACE_CDR_GIOP_MINOR_VERSION); - - /// Create an empty input stream. The caller is responsible for - /// putting the right data and providing the right alignment. - ACE_InputCDR (size_t bufsiz, - int byte_order = ACE_CDR::BYTE_ORDER_NATIVE, - ACE_CDR::Octet major_version = ACE_CDR_GIOP_MAJOR_VERSION, - ACE_CDR::Octet minor_version = ACE_CDR_GIOP_MINOR_VERSION); - - /// Create an input stream from an ACE_Message_Block - /** - * The alignment of the @a data block is carried into the new - * ACE_InputCDR object. This constructor either increments the - * @a data reference count, or copies the data (if it's a compound - * message block) so the caller can release the block immediately - * upon return. - */ - ACE_InputCDR (const ACE_Message_Block *data, - int byte_order = ACE_CDR::BYTE_ORDER_NATIVE, - ACE_CDR::Octet major_version = ACE_CDR_GIOP_MAJOR_VERSION, - ACE_CDR::Octet minor_version = ACE_CDR_GIOP_MINOR_VERSION, - ACE_Lock* lock = 0); - - /// Create an input stream from an ACE_Data_Block. The @a flag - /// indicates whether the @a data can be deleted by the CDR stream - /// or not - ACE_InputCDR (ACE_Data_Block *data, - ACE_Message_Block::Message_Flags flag = 0, - int byte_order = ACE_CDR::BYTE_ORDER_NATIVE, - ACE_CDR::Octet major_version = ACE_CDR_GIOP_MAJOR_VERSION, - ACE_CDR::Octet minor_version = ACE_CDR_GIOP_MINOR_VERSION); - - /// Create an input stream from an ACE_Data_Block. It also sets the - /// read and write pointers at the desired positions. This would be - /// helpful if the applications desires to create a new CDR stream - /// from a semi-processed datablock. - ACE_InputCDR (ACE_Data_Block *data, - ACE_Message_Block::Message_Flags flag, - size_t read_pointer_position, - size_t write_pointer_position, - int byte_order = ACE_CDR::BYTE_ORDER_NATIVE, - ACE_CDR::Octet major_version = ACE_CDR_GIOP_MAJOR_VERSION, - ACE_CDR::Octet minor_version = ACE_CDR_GIOP_MINOR_VERSION); - - /** - * These make a copy of the current stream state, but do not copy - * the internal buffer, so the same stream can be read multiple - * times efficiently. - */ - ACE_InputCDR (const ACE_InputCDR& rhs); - - ACE_InputCDR& operator= (const ACE_InputCDR& rhs); - - /// When interpreting indirected TypeCodes it is useful to make a - /// "copy" of the stream starting in the new position. - ACE_InputCDR (const ACE_InputCDR& rhs, - size_t size, - ACE_CDR::Long offset); - - /// This creates an encapsulated stream, the first byte must be (per - /// the spec) the byte order of the encapsulation. - ACE_InputCDR (const ACE_InputCDR& rhs, - size_t size); - - /// Create an input CDR from an output CDR. - ACE_InputCDR (const ACE_OutputCDR& rhs, - ACE_Allocator* buffer_allocator = 0, - ACE_Allocator* data_block_allocator = 0, - ACE_Allocator* message_block_allocator = 0); - - /// Helper class to transfer the contents from one input CDR to - /// another without requiring any extra memory allocations, data - /// copies or too many temporaries. - struct ACE_Export Transfer_Contents - { - Transfer_Contents (ACE_InputCDR &rhs); - - ACE_InputCDR &rhs_; - }; - /// Transfer the contents from @a rhs to a new CDR - ACE_InputCDR (Transfer_Contents rhs); - - /// Destructor - virtual ~ACE_InputCDR (void); - - /// Disambiguate overloading when extracting octets, chars, - /// booleans, and bounded strings - //@{ @name Helper classes - - struct ACE_Export to_boolean - { - explicit to_boolean (ACE_CDR::Boolean &b); - ACE_CDR::Boolean &ref_; - }; - - struct ACE_Export to_char - { - explicit to_char (ACE_CDR::Char &c); - ACE_CDR::Char &ref_; - }; - - struct ACE_Export to_wchar - { - explicit to_wchar (ACE_CDR::WChar &wc); - ACE_CDR::WChar &ref_; - }; - - struct ACE_Export to_octet - { - explicit to_octet (ACE_CDR::Octet &o); - ACE_CDR::Octet &ref_; - }; - - struct ACE_Export to_string - { - /** - * @deprecated The constructor taking a non-const string is now - * deprecated (C++ mapping 00-01-02), but we keep it - * around for backward compatibility. - */ - to_string (ACE_CDR::Char *&s, - ACE_CDR::ULong b); - to_string (const ACE_CDR::Char *&s, - ACE_CDR::ULong b); - const ACE_CDR::Char *&val_; - ACE_CDR::ULong bound_; - }; - - struct ACE_Export to_wstring - { - /// The constructor taking a non-const wstring is - /// now deprecated (C++ mapping 00-01-02), but we - /// keep it around for backward compatibility. - to_wstring (ACE_CDR::WChar *&ws, - ACE_CDR::ULong b); - to_wstring (const ACE_CDR::WChar *&ws, - ACE_CDR::ULong b); - const ACE_CDR::WChar *&val_; - ACE_CDR::ULong bound_; - }; - - /// Helper classes for extracting bounded strings into std::string/wstring. - struct ACE_Export to_std_string - { - to_std_string (std::string &s, - ACE_CDR::ULong b); - std::string &val_; - ACE_CDR::ULong bound_; - }; - -#if !defined(ACE_LACKS_STD_WSTRING) - struct ACE_Export to_std_wstring - { - to_std_wstring (std::wstring &ws, - ACE_CDR::ULong b); - std::wstring &val_; - ACE_CDR::ULong bound_; - }; -#endif /* ACE_LACKS_STD_WSTRING */ - //@} - - /** - * Return @c false on failure and @c true on success. - */ - //@{ @name Read basic IDL types - ACE_CDR::Boolean read_boolean (ACE_CDR::Boolean& x); - ACE_CDR::Boolean read_char (ACE_CDR::Char &x); - ACE_CDR::Boolean read_wchar (ACE_CDR::WChar& x); - ACE_CDR::Boolean read_octet (ACE_CDR::Octet& x); - ACE_CDR::Boolean read_short (ACE_CDR::Short &x); - ACE_CDR::Boolean read_ushort (ACE_CDR::UShort &x); - ACE_CDR::Boolean read_long (ACE_CDR::Long &x); - ACE_CDR::Boolean read_ulong (ACE_CDR::ULong &x); - ACE_CDR::Boolean read_longlong (ACE_CDR::LongLong& x); - ACE_CDR::Boolean read_ulonglong (ACE_CDR::ULongLong& x); - ACE_CDR::Boolean read_float (ACE_CDR::Float &x); - ACE_CDR::Boolean read_double (ACE_CDR::Double &x); - ACE_CDR::Boolean read_longdouble (ACE_CDR::LongDouble &x); - ACE_CDR::Boolean read_fixed (ACE_CDR::Fixed &x); - - ACE_CDR::Boolean read_string (ACE_CDR::Char *&x); - ACE_CDR::Boolean read_string (ACE_CString &x); - ACE_CDR::Boolean read_wstring (ACE_CDR::WChar*& x); - ACE_CDR::Boolean read_string (std::string& x); -#if !defined(ACE_LACKS_STD_WSTRING) - ACE_CDR::Boolean read_wstring (std::wstring& x); -#endif - //@} - - /** - * The buffer @a x must be large enough to contain @a length - * elements. - * Return @c false on failure and @c true on success. - */ - //@{ @name Read basic IDL types arrays - ACE_CDR::Boolean read_boolean_array (ACE_CDR::Boolean* x, - ACE_CDR::ULong length); - ACE_CDR::Boolean read_char_array (ACE_CDR::Char *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean read_wchar_array (ACE_CDR::WChar* x, - ACE_CDR::ULong length); - ACE_CDR::Boolean read_octet_array (ACE_CDR::Octet* x, - ACE_CDR::ULong length); - ACE_CDR::Boolean read_short_array (ACE_CDR::Short *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean read_ushort_array (ACE_CDR::UShort *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean read_long_array (ACE_CDR::Long *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean read_ulong_array (ACE_CDR::ULong *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean read_longlong_array (ACE_CDR::LongLong* x, - ACE_CDR::ULong length); - ACE_CDR::Boolean read_ulonglong_array (ACE_CDR::ULongLong* x, - ACE_CDR::ULong length); - ACE_CDR::Boolean read_float_array (ACE_CDR::Float *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean read_double_array (ACE_CDR::Double *x, - ACE_CDR::ULong length); - ACE_CDR::Boolean read_longdouble_array (ACE_CDR::LongDouble* x, - ACE_CDR::ULong length); - //@} - - /** - * Return @c false on failure and @c true on success. - */ - //@{ @name Skip elements - ACE_CDR::Boolean skip_boolean (void); - ACE_CDR::Boolean skip_char (void); - ACE_CDR::Boolean skip_wchar (void); - ACE_CDR::Boolean skip_octet (void); - ACE_CDR::Boolean skip_short (void); - ACE_CDR::Boolean skip_ushort (void); - ACE_CDR::Boolean skip_long (void); - ACE_CDR::Boolean skip_ulong (void); - ACE_CDR::Boolean skip_longlong (void); - ACE_CDR::Boolean skip_ulonglong (void); - ACE_CDR::Boolean skip_float (void); - ACE_CDR::Boolean skip_double (void); - ACE_CDR::Boolean skip_longdouble (void); - ACE_CDR::Boolean skip_fixed (void); - //@} - - /** - * The next field must be a string, this method skips it. It is - * useful in parsing a TypeCode. - * @return @c false on failure and @c true on success. - */ - ACE_CDR::Boolean skip_wstring (void); - ACE_CDR::Boolean skip_string (void); - - /// Skip @a n bytes in the CDR stream. - /** - * @return @c false on failure and @c true on success. - */ - ACE_CDR::Boolean skip_bytes (size_t n); - - /// returns @c false if a problem has been detected. - bool good_bit (void) const; - - /** - * @return The start of the message block chain for this CDR - * stream. - * - * @note In the current implementation the chain has length 1, but - * we are planning to change that. - */ - const ACE_Message_Block* start (void) const; - - // = The following functions are useful to read the contents of the - // CDR stream from a socket or file. - - /** - * Grow the internal buffer, reset @c rd_ptr to the first byte in - * the new buffer that is properly aligned, and set @c wr_ptr to @c - * rd_ptr @c + @c newsize - */ - int grow (size_t newsize); - - /** - * After reading and partially parsing the contents the user can - * detect a change in the byte order, this method will let him/her - * change it. - */ - void reset_byte_order (int byte_order); - - /// Re-initialize the CDR stream, copying the contents of the chain - /// of message_blocks starting from @a data. - void reset (const ACE_Message_Block *data, - int byte_order); - - /// Steal the contents from the current CDR. - ACE_Message_Block *steal_contents (void); - - /// Steal the contents of @a cdr and make a shallow copy into this - /// stream. - void steal_from (ACE_InputCDR &cdr); - - /// Exchange data blocks with the caller of this method. The read - /// and write pointers are also exchanged. - /** - * @note We now do only with the start_ message block. - */ - void exchange_data_blocks (ACE_InputCDR &cdr); - - /// Copy the data portion from the @a cdr to this cdr and return the - /// data content (ie. the ACE_Data_Block) from this CDR to the - /// caller. - /** - * @note The caller is responsible for managing the memory of the - * returned ACE_Data_Block. - */ - ACE_Data_Block* clone_from (ACE_InputCDR &cdr); - - /// Re-initialize the CDR stream, forgetting about the old contents - /// of the stream and allocating a new buffer (from the allocators). - void reset_contents (void); - - /// Returns the current position for the @c rd_ptr. - char* rd_ptr (void); - - /// Returns the current position for the @c wr_ptr. - char* wr_ptr (void); - - /// Return how many bytes are left in the stream. - size_t length (void) const; - - /** - * Utility function to allow the user more flexibility. - * Skips up to the nearest @a alignment-byte boundary. - * Argument MUST be a power of 2. - * - * @return 0 on success and -1 on failure. - */ - int align_read_ptr (size_t alignment); - - /// If @c true then this stream is writing in non-native byte order. - /// This is only meaningful if ACE_ENABLE_SWAP_ON_WRITE is defined. - bool do_byte_swap (void) const; - - /// If @c do_byte_swap() returns @c false, this returns - /// ACE_CDR_BYTE_ORDER else it returns !ACE_CDR_BYTE_ORDER. - int byte_order (void) const; - - /// Access the codeset translators. They can be nil! - ACE_Char_Codeset_Translator *char_translator (void) const; - ACE_WChar_Codeset_Translator *wchar_translator (void) const; - - /// Set the codeset translators. - void char_translator (ACE_Char_Codeset_Translator *); - void wchar_translator (ACE_WChar_Codeset_Translator *); - - /** - * Returns (in @a buf) the next position in the buffer aligned to - * @a size. It advances the Message_Block @c rd_ptr past the data - * (i.e., @c buf @c + @c size). Sets the good_bit to @c false and - * returns a -1 on failure. - */ - int adjust (size_t size, - char *&buf); - - /// As above, but now the size and alignment requirements may be - /// different. - int adjust (size_t size, - size_t align, - char *&buf); - - /// Set the underlying GIOP version.. - void set_version (ACE_CDR::Octet major, ACE_CDR::Octet minor); - - /// Set the underlying GIOP version.. - void get_version (ACE_CDR::Octet &major, ACE_CDR::Octet &minor); - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - /// Register and unregister our buffer size monitor. - void register_monitor (const char* id); - void unregister_monitor (void); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - -protected: - - /// The start of the chain of message blocks, even though in the - /// current version the chain always has length 1. - ACE_Message_Block start_; - - /// The CDR stream byte order does not match the one on the machine, - /// swapping is needed while reading. - bool do_byte_swap_; - - /// set to @c false when an error occurs. - bool good_bit_; - - /// The GIOP versions for this stream - ACE_CDR::Octet major_version_; - ACE_CDR::Octet minor_version_; - - /// If not nil, invoke for translation of character and string data. - ACE_Char_Codeset_Translator *char_translator_; - ACE_WChar_Codeset_Translator *wchar_translator_; - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - ACE::Monitor_Control::Size_Monitor *monitor_; -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - -private: - ACE_CDR::Boolean read_1 (ACE_CDR::Octet *x); - ACE_CDR::Boolean read_2 (ACE_CDR::UShort *x); - ACE_CDR::Boolean read_4 (ACE_CDR::ULong *x); - ACE_CDR::Boolean read_8 (ACE_CDR::ULongLong *x); - ACE_CDR::Boolean read_16 (ACE_CDR::LongDouble *x); - - // Several types can be read using the same routines, since TAO - // tries to use native types with known size for each CORBA type. - // We could use void* or char* to make the interface more - // consistent, but using native types let us exploit the strict - // alignment requirements of CDR streams and implement the - // operations using assignment. - - /** - * Read an array of @a length elements, each of @a size bytes and the - * start aligned at a multiple of @a align. The elements are assumed - * to be packed with the right alignment restrictions. It is mostly - * designed for buffers of the basic types. - * - * This operation uses @c memcpy; as explained above it is expected - * that using assignment is faster that @c memcpy for one element, - * but for several elements @c memcpy should be more efficient, it - * could be interesting to find the break even point and optimize - * for that case, but that would be too platform dependent. - */ - ACE_CDR::Boolean read_array (void* x, - size_t size, - size_t align, - ACE_CDR::ULong length); - - /** - * On those occasions when the native codeset for wchar is smaller than - * the size of a wchar_t, such as using UTF-16 with a 4-byte wchar_t, a - * special form of reading the array is needed. Actually, this should be - * a default translator. - */ - ACE_CDR::Boolean read_wchar_array_i (ACE_CDR::WChar * x, - ACE_CDR::ULong length); - - /// Move the rd_ptr ahead by @a offset bytes. - void rd_ptr (size_t offset); - - /// Points to the continuation field of the current message block. - char* end (void); -}; - -// **************************************************************** - -/** - * @class ACE_Char_Codeset_Translator - * - * @brief Codeset translation routines common to both Output and Input - * CDR streams. - * - * This class is a base class for defining codeset translation - * routines to handle the character set translations required by - * both CDR Input streams and CDR Output streams. - * - * Translators are reference counted. This allows for stateful as well - * as stateless translators. Stateless translators will be allocated - * once whereas CDR Streams own their own copy of a stateful translator. - */ -class ACE_Export ACE_Char_Codeset_Translator -{ -public: - virtual ~ACE_Char_Codeset_Translator (); - - /// Read a single character from the stream, converting from the - /// stream codeset to the native codeset - virtual ACE_CDR::Boolean read_char (ACE_InputCDR&, - ACE_CDR::Char&) = 0; - - /// Read a string from the stream, including the length, converting - /// the characters from the stream codeset to the native codeset - virtual ACE_CDR::Boolean read_string (ACE_InputCDR&, - ACE_CDR::Char *&) = 0; - - /// Read a std::string from the stream, including the length, converting - /// the characters from the stream codeset to the native codeset - /// (provide non-optimized default implementation) - virtual ACE_CDR::Boolean read_string (ACE_InputCDR&, - std::string &); - - /// Read an array of characters from the stream, converting the - /// characters from the stream codeset to the native codeset. - virtual ACE_CDR::Boolean read_char_array (ACE_InputCDR&, - ACE_CDR::Char*, - ACE_CDR::ULong) = 0; - - /// Write a single character to the stream, converting from the - /// native codeset to the stream codeset - virtual ACE_CDR::Boolean write_char (ACE_OutputCDR&, - ACE_CDR::Char) = 0; - - /// Write a string to the stream, including the length, converting - /// from the native codeset to the stream codeset - virtual ACE_CDR::Boolean write_string (ACE_OutputCDR&, - ACE_CDR::ULong, - const ACE_CDR::Char*) = 0; - - /// Write an array of characters to the stream, converting from the - /// native codeset to the stream codeset - virtual ACE_CDR::Boolean write_char_array (ACE_OutputCDR&, - const ACE_CDR::Char*, - ACE_CDR::ULong) = 0; - - virtual ACE_CDR::ULong ncs () = 0; - virtual ACE_CDR::ULong tcs () = 0; -protected: - /// Children have access to low-level routines because they cannot - /// use read_char or something similar (it would recurse). - ACE_CDR::Boolean read_1 (ACE_InputCDR& input, - ACE_CDR::Octet *x); - ACE_CDR::Boolean write_1 (ACE_OutputCDR& output, - const ACE_CDR::Octet *x); - - /// Efficiently read @a length elements of size @a size each from - /// @a input into @a x; the data must be aligned to @a align. - ACE_CDR::Boolean read_array (ACE_InputCDR& input, - void* x, - size_t size, - size_t align, - ACE_CDR::ULong length); - - /** - * Efficiently write @a length elements of size @a size from into - * . Before inserting the elements enough padding is added - * to ensure that the elements will be aligned to in the - * stream. - */ - ACE_CDR::Boolean write_array (ACE_OutputCDR& output, - const void *x, - size_t size, - size_t align, - ACE_CDR::ULong length); - - /** - * Exposes the stream implementation of , this is useful in - * many cases to minimize memory allocations during marshaling. - * On success @a buf will contain a contiguous area in the CDR stream - * that can hold @a size bytes aligned to @a align. - * Results - */ - int adjust (ACE_OutputCDR& out, - size_t size, - size_t align, - char *&buf); - - /// Used by derived classes to set errors in the CDR stream. - void good_bit (ACE_OutputCDR& out, bool bit); - - /// Obtain the CDR Stream's major & minor version values. - ACE_CDR::Octet major_version (ACE_InputCDR& input); - ACE_CDR::Octet minor_version (ACE_InputCDR& input); - ACE_CDR::Octet major_version (ACE_OutputCDR& output); - ACE_CDR::Octet minor_version (ACE_OutputCDR& output); -}; - -// **************************************************************** - -/** - * @class ACE_WChar_Codeset_Translator - * - * @brief Codeset translation routines common to both Output and Input - * CDR streams. - * - * This class is a base class for defining codeset translation - * routines to handle the character set translations required by - * both CDR Input streams and CDR Output streams. - */ -class ACE_Export ACE_WChar_Codeset_Translator -{ -public: - virtual ~ACE_WChar_Codeset_Translator (); - - virtual ACE_CDR::Boolean read_wchar (ACE_InputCDR&, - ACE_CDR::WChar&) = 0; - virtual ACE_CDR::Boolean read_wstring (ACE_InputCDR&, - ACE_CDR::WChar *&) = 0; -#if !defined(ACE_LACKS_STD_WSTRING) - /// Read a std::wstring from the stream, including the length, converting - /// the characters from the stream codeset to the native codeset - /// (provide non-optimized default implementation) - virtual ACE_CDR::Boolean read_wstring (ACE_InputCDR&, - std::wstring &); -#endif - virtual ACE_CDR::Boolean read_wchar_array (ACE_InputCDR&, - ACE_CDR::WChar*, - ACE_CDR::ULong) = 0; - virtual ACE_CDR::Boolean write_wchar (ACE_OutputCDR&, - ACE_CDR::WChar) = 0; - virtual ACE_CDR::Boolean write_wstring (ACE_OutputCDR&, - ACE_CDR::ULong, - const ACE_CDR::WChar*) = 0; - virtual ACE_CDR::Boolean write_wchar_array (ACE_OutputCDR&, - const ACE_CDR::WChar*, - ACE_CDR::ULong) = 0; - - virtual ACE_CDR::ULong ncs () = 0; - virtual ACE_CDR::ULong tcs () = 0; -protected: - /// Children have access to low-level routines because they cannot - /// use read_char or something similar (it would recurse). - ACE_CDR::Boolean read_1 (ACE_InputCDR& input, - ACE_CDR::Octet *x); - ACE_CDR::Boolean read_2 (ACE_InputCDR& input, - ACE_CDR::UShort *x); - ACE_CDR::Boolean read_4 (ACE_InputCDR& input, - ACE_CDR::ULong *x); - ACE_CDR::Boolean write_1 (ACE_OutputCDR& output, - const ACE_CDR::Octet *x); - ACE_CDR::Boolean write_2 (ACE_OutputCDR& output, - const ACE_CDR::UShort *x); - ACE_CDR::Boolean write_4 (ACE_OutputCDR& output, - const ACE_CDR::ULong *x); - - /// Efficiently read @a length elements of size @a size each from - /// @a input into @a x; the data must be aligned to @a align. - ACE_CDR::Boolean read_array (ACE_InputCDR& input, - void* x, - size_t size, - size_t align, - ACE_CDR::ULong length); - - /** - * Efficiently write @a length elements of size @a size from @a x into - * @a output. Before inserting the elements enough padding is added - * to ensure that the elements will be aligned to @a align in the - * stream. - */ - ACE_CDR::Boolean write_array (ACE_OutputCDR& output, - const void *x, - size_t size, - size_t align, - ACE_CDR::ULong length); - - /** - * Exposes the stream implementation of @a adjust, this is useful in - * many cases to minimize memory allocations during marshaling. - * On success @a buf will contain a contiguous area in the CDR stream - * that can hold @a size bytes aligned to @a align. - * Results - */ - int adjust (ACE_OutputCDR& out, - size_t size, - size_t align, - char *&buf); - - /// Used by derived classes to set errors in the CDR stream. - void good_bit (ACE_OutputCDR& out, bool bit); - - /// Obtain the CDR Stream's major & minor version values. - ACE_CDR::Octet major_version (ACE_InputCDR& input); - ACE_CDR::Octet minor_version (ACE_InputCDR& input); - ACE_CDR::Octet major_version (ACE_OutputCDR& output); - ACE_CDR::Octet minor_version (ACE_OutputCDR& output); - -}; - -// @@ These operators should not be inlined since they force SString.h -// to be included in this header. -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - const ACE_CString &x); - -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CString &x); - - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -# include "ace/CDR_Stream.inl" -#else /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Not used by CORBA or TAO -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_CDR::Char x); -// CDR output operators for primitive types - -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_CDR::Short x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_CDR::UShort x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_CDR::Long x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_CDR::ULong x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_CDR::LongLong x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_CDR::ULongLong x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR& os, - ACE_CDR::LongDouble x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_CDR::Float x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_CDR::Double x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - const ACE_CDR::Fixed &x); - -// CDR output operator from helper classes - -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_boolean x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_char x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_wchar x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_octet x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_string x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_wstring x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - const ACE_CDR::Char* x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - const ACE_CDR::WChar* x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_std_string x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - const std::string& x); -#if !defined(ACE_LACKS_STD_WSTRING) -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - ACE_OutputCDR::from_std_wstring x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_OutputCDR &os, - const std::wstring& x); -#endif - -// Not used by CORBA or TAO -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::Char &x); -// CDR input operators for primitive types - -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::Short &x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::UShort &x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::Long &x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::ULong &x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::LongLong &x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::ULongLong &x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::LongDouble &x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::Float &x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::Double &x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::Fixed &x); - -// CDR input operator from helper classes - -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_InputCDR::to_boolean x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_InputCDR::to_char x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_InputCDR::to_wchar x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_InputCDR::to_octet x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_InputCDR::to_string x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_InputCDR::to_wstring x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::Char*& x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - ACE_CDR::WChar*& x); -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_InputCDR &os, - ACE_InputCDR::to_std_string x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - std::string& x); -#if !defined(ACE_LACKS_STD_WSTRING) -extern ACE_Export ACE_CDR::Boolean operator<< (ACE_InputCDR &os, - ACE_InputCDR::to_std_wstring x); -extern ACE_Export ACE_CDR::Boolean operator>> (ACE_InputCDR &is, - std::wstring& x); -#endif - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* __ACE_INLINE__ */ - -#if defined (GEN_OSTREAM_OPS) - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// ostream insertion operators for debugging code generated from IDL. All -// but these below are either in generated code itself or are unambiguous -// primitive types. - -ACE_Export std::ostream& operator<< (std::ostream &os, - ACE_OutputCDR::from_boolean x); - -ACE_Export std::ostream& operator<< (std::ostream &os, - ACE_OutputCDR::from_char x); - -ACE_Export std::ostream& operator<< (std::ostream &os, - ACE_OutputCDR::from_wchar x); - -ACE_Export std::ostream& operator<< (std::ostream &os, - ACE_OutputCDR::from_octet x); - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* GEN_OSTREAM_OPS */ - -#include /**/ "ace/post.h" - -#endif /* ACE_CDR_STREAM_H */ diff --git a/deps/acelite/ace/CDR_Stream.inl b/deps/acelite/ace/CDR_Stream.inl deleted file mode 100644 index fe25108da..000000000 --- a/deps/acelite/ace/CDR_Stream.inl +++ /dev/null @@ -1,1926 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_string.h" -#include "ace/OS_Memory.h" - -// **************************************************************** - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// implementing the special types -ACE_INLINE -ACE_OutputCDR::from_boolean::from_boolean (ACE_CDR::Boolean b) - : val_ (b) -{ -} - -ACE_INLINE -ACE_InputCDR::to_boolean::to_boolean (ACE_CDR::Boolean &b) - : ref_ (b) -{ -} - -ACE_INLINE -ACE_OutputCDR::from_octet::from_octet (ACE_CDR::Octet o) - : val_ (o) -{ -} - -ACE_INLINE -ACE_InputCDR::to_octet::to_octet (ACE_CDR::Octet &o) - : ref_ (o) -{ -} - -ACE_INLINE -ACE_OutputCDR::from_char::from_char (ACE_CDR::Char c) - : val_ (c) -{ -} - -ACE_INLINE -ACE_InputCDR::to_char::to_char (ACE_CDR::Char &c) - : ref_ (c) -{ -} - -ACE_INLINE -ACE_OutputCDR::from_wchar::from_wchar (ACE_CDR::WChar wc) - : val_ (wc) -{ -} - -ACE_INLINE -ACE_InputCDR::to_wchar::to_wchar (ACE_CDR::WChar &wc) - : ref_ (wc) -{ -} - -ACE_INLINE -ACE_OutputCDR::from_string::from_string (ACE_CDR::Char *s, - ACE_CDR::ULong b, - ACE_CDR::Boolean nocopy) - : val_ (s), - bound_ (b), - nocopy_ (nocopy) -{ -} - -ACE_INLINE -ACE_OutputCDR::from_string::from_string (const ACE_CDR::Char *s, - ACE_CDR::ULong b, - ACE_CDR::Boolean nocopy) - : val_ (const_cast (s)), - bound_ (b), - nocopy_ (nocopy) -{ -} - -ACE_INLINE -ACE_InputCDR::to_string::to_string (ACE_CDR::Char *&s, - ACE_CDR::ULong b) - : val_ (const_cast (s)), - bound_ (b) -{ -} - -ACE_INLINE -ACE_InputCDR::to_string::to_string (const ACE_CDR::Char *&s, - ACE_CDR::ULong b) - : val_ (s), - bound_ (b) -{ -} - -ACE_INLINE -ACE_OutputCDR::from_wstring::from_wstring (ACE_CDR::WChar *ws, - ACE_CDR::ULong b, - ACE_CDR::Boolean nocopy) - : val_ (ws), - bound_ (b), - nocopy_ (nocopy) -{ -} - -ACE_INLINE -ACE_OutputCDR::from_wstring::from_wstring (const ACE_CDR::WChar *ws, - ACE_CDR::ULong b, - ACE_CDR::Boolean nocopy) - : val_ (const_cast (ws)), - bound_ (b), - nocopy_ (nocopy) -{ -} - -ACE_INLINE -ACE_InputCDR::to_wstring::to_wstring (ACE_CDR::WChar *&ws, - ACE_CDR::ULong b) - : val_ (const_cast (ws)), - bound_ (b) -{ -} - -ACE_INLINE -ACE_InputCDR::to_wstring::to_wstring (const ACE_CDR::WChar *&ws, - ACE_CDR::ULong b) - : val_ (ws), - bound_ (b) -{ -} - -ACE_INLINE -ACE_InputCDR::to_std_string::to_std_string (std::string &s, - ACE_CDR::ULong b) - : val_ (s), - bound_ (b) -{ -} - -ACE_INLINE -ACE_OutputCDR::from_std_string::from_std_string (const std::string &ws, - ACE_CDR::ULong b) - : val_ (ws), - bound_ (b) -{ -} - -#if !defined(ACE_LACKS_STD_WSTRING) -ACE_INLINE -ACE_InputCDR::to_std_wstring::to_std_wstring (std::wstring &s, - ACE_CDR::ULong b) - : val_ (s), - bound_ (b) -{ -} - -ACE_INLINE -ACE_OutputCDR::from_std_wstring::from_std_wstring (const std::wstring &ws, - ACE_CDR::ULong b) - : val_ (ws), - bound_ (b) -{ -} -#endif - -ACE_INLINE -ACE_InputCDR::Transfer_Contents::Transfer_Contents (ACE_InputCDR &rhs) - : rhs_ (rhs) -{ -} - -// **************************************************************** - -ACE_INLINE -ACE_OutputCDR::~ACE_OutputCDR (void) -{ - if (this->start_.cont () != 0) - { - ACE_Message_Block::release (this->start_.cont ()); - this->start_.cont (0); - } - - this->current_ = 0; - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - this->monitor_->remove_ref (); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_INLINE void -ACE_OutputCDR::reset (void) -{ - this->current_ = &this->start_; - this->current_is_writable_ = true; - ACE_CDR::mb_align (&this->start_); - -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - this->current_alignment_ = 0; -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - - // It is tempting not to remove the memory, but we need to do so to - // release any potential user buffers chained in the continuation - // field. - - ACE_Message_Block * const cont = this->start_.cont (); - if (cont) - { - ACE_Message_Block::release (cont); - this->start_.cont (0); - } - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - this->monitor_->receive (this->start_.total_size ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -// Encode the CDR stream. - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_octet (ACE_CDR::Octet x) -{ - return this->write_1 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_boolean (ACE_CDR::Boolean x) -{ - return - static_cast ( - this->write_octet ( - x - ? static_cast (1) - : static_cast (0))); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_char (ACE_CDR::Char x) -{ - if (this->char_translator_ == 0) - { - ACE_CDR::Octet temp = static_cast (x); - return this->write_1 (&temp); - } - return this->char_translator_->write_char (*this, x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_short (ACE_CDR::Short x) -{ - ACE_CDR::UShort temp = static_cast (x); - return this->write_2 (&temp); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_ushort (ACE_CDR::UShort x) -{ - return this->write_2 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_long (ACE_CDR::Long x) -{ - ACE_CDR::ULong temp = static_cast (x); - return this->write_4 (&temp); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_ulong (ACE_CDR::ULong x) -{ - return this->write_4 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_longlong (const ACE_CDR::LongLong &x) -{ - void const * const temp = &x; - return this->write_8 (reinterpret_cast (temp)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_ulonglong (const ACE_CDR::ULongLong &x) -{ - return this->write_8 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_float (ACE_CDR::Float x) -{ - void const * const temp = &x; - return this->write_4 (reinterpret_cast (temp)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_double (const ACE_CDR::Double &x) -{ - void const * const temp = &x; - return this->write_8 (reinterpret_cast (temp)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_longdouble (const ACE_CDR::LongDouble &x) -{ - return this->write_16 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_fixed (const ACE_CDR::Fixed &x) -{ - int n; - const ACE_CDR::Octet *arr = x.to_octets (n); - return this->write_array (arr, ACE_CDR::OCTET_SIZE, ACE_CDR::OCTET_ALIGN, n); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_string (const ACE_CDR::Char *x) -{ - if (x) - { - ACE_CDR::ULong const len = - static_cast (ACE_OS::strlen (x)); - return this->write_string (len, x); - } - - return this->write_string (0, 0); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_wstring (const ACE_CDR::WChar *x) -{ - if (x) - { - ACE_CDR::ULong const len = - static_cast (ACE_OS::strlen (x)); - return this->write_wstring (len, x); - } - - return this->write_wstring (0, 0); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_string (const std::string &x) -{ - ACE_CDR::ULong const len = - static_cast (x.size ()); - return this->write_string (len, - x.empty () ? 0 : x.c_str ()); -} - -#if !defined(ACE_LACKS_STD_WSTRING) -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_wstring (const std::wstring &x) -{ - ACE_CDR::ULong const len = - static_cast (x.size ()); - return this->write_wstring (len, - x.empty () ? 0 : x.c_str ()); -} -#endif - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_char_array (const ACE_CDR::Char *x, - ACE_CDR::ULong length) -{ - if (this->char_translator_ == 0) - return this->write_array (x, - ACE_CDR::OCTET_SIZE, - ACE_CDR::OCTET_ALIGN, - length); - return this->char_translator_->write_char_array (*this, x, length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_wchar_array (const ACE_CDR::WChar* x, - ACE_CDR::ULong length) -{ - if (this->wchar_translator_) - return this->wchar_translator_->write_wchar_array (*this, x, length); - - if (ACE_OutputCDR::wchar_maxbytes_ == 0) - { - errno = EACCES; - return (ACE_CDR::Boolean) (this->good_bit_ = false); - } - - if (ACE_OutputCDR::wchar_maxbytes_ == sizeof (ACE_CDR::WChar)) - return this->write_array (x, - sizeof (ACE_CDR::WChar), - sizeof (ACE_CDR::WChar) == 2 - ? ACE_CDR::SHORT_ALIGN - : ACE_CDR::LONG_ALIGN, - length); - return this->write_wchar_array_i (x,length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_octet_array (const ACE_CDR::Octet* x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::OCTET_SIZE, - ACE_CDR::OCTET_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_short_array (const ACE_CDR::Short *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::SHORT_SIZE, - ACE_CDR::SHORT_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_ushort_array (const ACE_CDR::UShort *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::SHORT_SIZE, - ACE_CDR::SHORT_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_long_array (const ACE_CDR::Long *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONG_SIZE, - ACE_CDR::LONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_ulong_array (const ACE_CDR::ULong *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONG_SIZE, - ACE_CDR::LONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_longlong_array (const ACE_CDR::LongLong *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONGLONG_SIZE, - ACE_CDR::LONGLONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_ulonglong_array (const ACE_CDR::ULongLong *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONGLONG_SIZE, - ACE_CDR::LONGLONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_float_array (const ACE_CDR::Float *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONG_SIZE, - ACE_CDR::LONG_ALIGN, - length); -} - - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_double_array (const ACE_CDR::Double *x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONGLONG_SIZE, - ACE_CDR::LONGLONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::write_longdouble_array (const ACE_CDR::LongDouble* x, - ACE_CDR::ULong length) -{ - return this->write_array (x, - ACE_CDR::LONGDOUBLE_SIZE, - ACE_CDR::LONGDOUBLE_ALIGN, - length); -} - -ACE_INLINE bool -ACE_OutputCDR::good_bit (void) const -{ - return this->good_bit_; -} - -ACE_INLINE int -ACE_OutputCDR::adjust (size_t size, - size_t align, - char*& buf) -{ - if (!this->current_is_writable_) - return this->grow_and_adjust (size, align, buf); - -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - size_t const offset = - ACE_align_binary (this->current_alignment_, align) - - this->current_alignment_; - - buf = this->current_->wr_ptr () + offset; -#else - buf = this->current_->wr_ptr (); -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - - char * const end = buf + size; - - if (end <= this->current_->end () && - end >= buf) - { -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - this->current_alignment_ += offset + size; -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - this->current_->wr_ptr (end); - -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - this->monitor_->receive (this->total_length ()); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ - - return 0; - } - - return this->grow_and_adjust (size, align, buf); -} - -ACE_INLINE int -ACE_OutputCDR::adjust (size_t size, char*& buf) -{ - return this->adjust (size, size, buf); -} - -ACE_INLINE void -ACE_OutputCDR::set_version (ACE_CDR::Octet major, ACE_CDR::Octet minor) -{ - this->major_version_ = major; - this->minor_version_ = minor; -} - -ACE_INLINE void -ACE_OutputCDR::get_version (ACE_CDR::Octet &major, ACE_CDR::Octet &minor) -{ - major = this->major_version_; - minor = this->minor_version_; -} - - -ACE_INLINE const ACE_Message_Block* -ACE_OutputCDR::begin (void) const -{ - return &this->start_; -} - -ACE_INLINE const ACE_Message_Block* -ACE_OutputCDR::end (void) const -{ - return this->current_->cont (); -} - -ACE_INLINE const ACE_Message_Block* -ACE_OutputCDR::current (void) const -{ - return this->current_; -} - -ACE_INLINE size_t -ACE_OutputCDR::total_length (void) const -{ - return ACE_CDR::total_length (this->begin (), this->end ()); -} - -ACE_INLINE const char* -ACE_OutputCDR::buffer (void) const -{ - return this->start_.rd_ptr (); -} - -ACE_INLINE size_t -ACE_OutputCDR::length (void) const -{ - return this->start_.length (); -} - -ACE_INLINE bool -ACE_OutputCDR::do_byte_swap (void) const -{ - return this->do_byte_swap_; -} - -ACE_INLINE int -ACE_OutputCDR::byte_order (void) const -{ - if (this->do_byte_swap ()) - return !ACE_CDR_BYTE_ORDER; - else - return ACE_CDR_BYTE_ORDER; -} - -ACE_INLINE void -ACE_OutputCDR::reset_byte_order (int byte_order) -{ - this->do_byte_swap_ = (byte_order != ACE_CDR_BYTE_ORDER); -} - -ACE_INLINE size_t -ACE_OutputCDR::current_alignment (void) const -{ -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - return this->current_alignment_; -#else - // Default value set to 0 - return 0; -#endif /* ACE_LACKS_CDR_ALIGNMENT */ -} - -ACE_INLINE void -ACE_OutputCDR::current_alignment (size_t current_alignment) -{ -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - this->current_alignment_ = current_alignment; -#else - ACE_UNUSED_ARG (current_alignment); -#endif /* ACE_LACKS_CDR_ALIGNMENT */ -} - -ACE_INLINE int -ACE_OutputCDR::align_write_ptr (size_t alignment) -{ -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - char *dummy; - return this->adjust (0, alignment, dummy); -#else - ACE_UNUSED_ARG (alignment); - // A return value of -1 from this function is used - // to indicate failure, returning 0 - return 0; -#endif /* ACE_LACKS_CDR_ALIGNMENT */ -} - -ACE_INLINE ACE_Char_Codeset_Translator * -ACE_OutputCDR::char_translator (void) const -{ - return this->char_translator_; -} - -ACE_INLINE ACE_WChar_Codeset_Translator * -ACE_OutputCDR::wchar_translator (void) const -{ - return this->wchar_translator_; -} - -ACE_INLINE void -ACE_OutputCDR::char_translator (ACE_Char_Codeset_Translator * ctran) -{ - this->char_translator_ = ctran; -} - -ACE_INLINE void -ACE_OutputCDR::wchar_translator (ACE_WChar_Codeset_Translator * wctran) -{ - this->wchar_translator_ = wctran; -} - -// **************************************************************** - -ACE_INLINE -ACE_InputCDR::~ACE_InputCDR (void) -{ -#if defined (ACE_HAS_MONITOR_POINTS) && (ACE_HAS_MONITOR_POINTS == 1) - this->monitor_->remove_ref (); -#endif /* ACE_HAS_MONITOR_POINTS==1 */ -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_octet (ACE_CDR::Octet& x) -{ - return this->read_1 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_boolean (ACE_CDR::Boolean& x) -{ - ACE_CDR::Octet tmp = 0; - (void) this->read_octet (tmp); - x = tmp ? true : false; - return (ACE_CDR::Boolean) this->good_bit_; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_char (ACE_CDR::Char &x) -{ - if (this->char_translator_ == 0) - { - void *temp = &x; - return this->read_1 (reinterpret_cast (temp)); - } - return this->char_translator_->read_char (*this, x); -} - - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_short (ACE_CDR::Short &x) -{ - void *temp = &x; - return this->read_2 (reinterpret_cast (temp)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_ushort (ACE_CDR::UShort &x) -{ - return this->read_2 (&x); -} - - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_long (ACE_CDR::Long &x) -{ - void *temp = &x; - return this->read_4 (reinterpret_cast (temp)); -} - - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_ulong (ACE_CDR::ULong &x) -{ - return this->read_4 (&x); -} - - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_longlong (ACE_CDR::LongLong &x) -{ - void *temp = &x; - return this->read_8 (reinterpret_cast (temp)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_ulonglong (ACE_CDR::ULongLong &x) -{ - return this->read_8 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_float (ACE_CDR::Float &x) -{ - void *temp = &x; - return this->read_4 (reinterpret_cast (temp)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_double (ACE_CDR::Double &x) -{ - void *temp = &x; - return this->read_8 (reinterpret_cast (temp)); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_longdouble (ACE_CDR::LongDouble &x) -{ - return this->read_16 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_fixed (ACE_CDR::Fixed &x) -{ - ACE_CDR::Octet a[16]; - for (int i = 0; i < 16; ++i) - { - if (!this->read_1 (a + i)) - return false; - const unsigned low = a[i] & 0xf; - if (low == ACE_CDR::Fixed::POSITIVE || - low == ACE_CDR::Fixed::NEGATIVE) - { - x = ACE_CDR::Fixed::from_octets (a, i + 1); - return true; - } - } - - return false; -} - -ACE_INLINE size_t -ACE_InputCDR::length (void) const -{ - return this->start_.length (); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_char_array (ACE_CDR::Char* x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length > this->length ()) - { - this->good_bit_ = false; - return false; - } - - if (this->char_translator_ == 0) - return this->read_array (x, - ACE_CDR::OCTET_SIZE, - ACE_CDR::OCTET_ALIGN, - length); - return this->char_translator_->read_char_array (*this, x, length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_wchar_array (ACE_CDR::WChar* x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length * ACE_OutputCDR::wchar_maxbytes_ > this->length ()) - { - this->good_bit_ = false; - return false; - } - - if (this->wchar_translator_ != 0) - return this->wchar_translator_->read_wchar_array (*this, x, length); - if (ACE_OutputCDR::wchar_maxbytes_ != sizeof (ACE_CDR::WChar)) - return this->read_wchar_array_i (x, length); - return this->read_array (x, - sizeof (ACE_CDR::WChar), - sizeof (ACE_CDR::WChar) == 2 - ? ACE_CDR::SHORT_ALIGN - : ACE_CDR::LONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_octet_array (ACE_CDR::Octet* x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length * ACE_CDR::OCTET_SIZE > this->length ()) - { - this->good_bit_ = false; - return false; - } - - return this->read_array (x, - ACE_CDR::OCTET_SIZE, - ACE_CDR::OCTET_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_short_array (ACE_CDR::Short *x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length * ACE_CDR::SHORT_SIZE > this->length ()) - { - this->good_bit_ = false; - return false; - } - - return this->read_array (x, - ACE_CDR::SHORT_SIZE, - ACE_CDR::SHORT_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_ushort_array (ACE_CDR::UShort *x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length * ACE_CDR::SHORT_SIZE > this->length ()) - { - this->good_bit_ = false; - return false; - } - - return this->read_array (x, - ACE_CDR::SHORT_SIZE, - ACE_CDR::SHORT_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_long_array (ACE_CDR::Long *x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length * ACE_CDR::LONG_SIZE > this->length ()) - { - this->good_bit_ = false; - return false; - } - - return this->read_array (x, - ACE_CDR::LONG_SIZE, - ACE_CDR::LONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_ulong_array (ACE_CDR::ULong *x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length * ACE_CDR::LONG_SIZE > this->length ()) - { - this->good_bit_ = false; - return false; - } - - return this->read_array (x, - ACE_CDR::LONG_SIZE, - ACE_CDR::LONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_longlong_array (ACE_CDR::LongLong *x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length * ACE_CDR::LONGLONG_SIZE > this->length ()) - { - this->good_bit_ = false; - return false; - } - - return this->read_array (x, - ACE_CDR::LONGLONG_SIZE, - ACE_CDR::LONGLONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_ulonglong_array (ACE_CDR::ULongLong *x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length * ACE_CDR::LONGLONG_SIZE > this->length ()) - { - this->good_bit_ = false; - return false; - } - - return this->read_array (x, - ACE_CDR::LONGLONG_SIZE, - ACE_CDR::LONGLONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_float_array (ACE_CDR::Float *x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length * ACE_CDR::LONG_SIZE > this->length ()) - { - this->good_bit_ = false; - return false; - } - - return this->read_array (x, - ACE_CDR::LONG_SIZE, - ACE_CDR::LONG_ALIGN, - length); -} - - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_double_array (ACE_CDR::Double *x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length * ACE_CDR::LONGLONG_SIZE > this->length ()) - { - this->good_bit_ = false; - return false; - } - - return this->read_array (x, - ACE_CDR::LONGLONG_SIZE, - ACE_CDR::LONGLONG_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::read_longdouble_array (ACE_CDR::LongDouble* x, - ACE_CDR::ULong length) -{ - // Make sure the length of the array isn't greater than the length of - // the stream. - if (length * ACE_CDR::LONGDOUBLE_SIZE > this->length ()) - { - this->good_bit_ = false; - return false; - } - return this->read_array (x, - ACE_CDR::LONGDOUBLE_SIZE, - ACE_CDR::LONGDOUBLE_ALIGN, - length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_octet (void) -{ - ACE_CDR::Octet x; - return this->read_1 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_char (void) -{ - return this->skip_octet (); // sizeof (Char) == sizeof (Octet) -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_boolean (void) -{ - return this->skip_octet () && this->good_bit_; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_ushort (void) -{ - ACE_CDR::UShort x; - return this->read_2 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_short (void) -{ - return this->skip_ushort (); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_ulong (void) -{ - ACE_CDR::ULong x; - return this->read_4 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_long (void) -{ - return this->skip_ulong (); // sizeof (Long) == sizeof (ULong) -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_ulonglong (void) -{ - ACE_CDR::ULongLong x; - return this->read_8 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_longlong (void) -{ - return this->skip_ulonglong (); // sizeof (LongLong) == sizeof (ULongLong) -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_float (void) -{ - return this->skip_ulong (); // sizeof(Float) == sizeof (ULong) -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_double (void) -{ - return this->skip_ulonglong (); // sizeof(Double) == sizeof (ULongLong) -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_longdouble (void) -{ - ACE_CDR::LongDouble x; - return this->read_16 (&x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_InputCDR::skip_fixed (void) -{ - for (int i = 0; i < 16; ++i) - { - ACE_CDR::Octet x; - if (!this->read_1 (&x)) - return false; - const unsigned low = x & 0xf; - if (low == 0xc || low == 0xd) - return true; - } - return false; -} - -ACE_INLINE char* -ACE_InputCDR::end (void) -{ - return this->start_.end (); -} - -ACE_INLINE void -ACE_InputCDR::rd_ptr (size_t offset) -{ - this->start_.rd_ptr (offset); -} - -ACE_INLINE char* -ACE_InputCDR::rd_ptr (void) -{ - return this->start_.rd_ptr (); -} - -ACE_INLINE char* -ACE_InputCDR::wr_ptr (void) -{ - return this->start_.wr_ptr (); -} - -ACE_INLINE int -ACE_InputCDR::adjust (size_t size, - size_t align, - char*& buf) -{ -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - buf = ACE_ptr_align_binary (this->rd_ptr (), align); -#else - buf = this->rd_ptr (); -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - - char * const end = buf + size; - if (end <= this->wr_ptr ()) - { - this->start_.rd_ptr (end); - return 0; - } - - this->good_bit_ = false; - return -1; -#if defined (ACE_LACKS_CDR_ALIGNMENT) - ACE_UNUSED_ARG (align); -#endif /* ACE_LACKS_CDR_ALIGNMENT */ -} - -ACE_INLINE int -ACE_InputCDR::adjust (size_t size, - char*& buf) -{ - return this->adjust (size, size, buf); -} - -ACE_INLINE const ACE_Message_Block* -ACE_InputCDR::start (void) const -{ - return &this->start_; -} - -ACE_INLINE bool -ACE_InputCDR::good_bit (void) const -{ - return this->good_bit_; -} - -// **************************************************************** - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_CDR::Char x) -{ - os.write_char (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_CDR::Short x) -{ - os.write_short (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_CDR::UShort x) -{ - os.write_ushort (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_CDR::Long x) -{ - os.write_long (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_CDR::ULong x) -{ - os.write_ulong (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_CDR::LongLong x) -{ - os.write_longlong (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_CDR::ULongLong x) -{ - os.write_ulonglong (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_CDR::LongDouble x) -{ - os.write_longdouble (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_CDR::Float x) -{ - os.write_float (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_CDR::Double x) -{ - os.write_double (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, const ACE_CDR::Fixed &x) -{ - os.write_fixed (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, const ACE_CDR::Char *x) -{ - os.write_string (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, const ACE_CDR::WChar *x) -{ - os.write_wstring (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_std_string x) -{ - ACE_CDR::ULong len = - static_cast (x.val_.size ()); - - os.write_string (len, x.val_.c_str ()); - return - (ACE_CDR::Boolean) (os.good_bit () && (!x.bound_ || len <= x.bound_)); -} - -#if !defined(ACE_LACKS_STD_WSTRING) -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_std_wstring x) -{ - ACE_CDR::ULong len = - static_cast (x.val_.size ()); - - os.write_wstring (len, x.val_.c_str ()); - return - (ACE_CDR::Boolean) (os.good_bit () && (!x.bound_ || len <= x.bound_)); -} -#endif - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, const std::string& x) -{ - os.write_string (x); - return (ACE_CDR::Boolean) os.good_bit (); -} - -#if !defined(ACE_LACKS_STD_WSTRING) -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, const std::wstring& x) -{ - os.write_wstring (x); - return (ACE_CDR::Boolean) os.good_bit (); -} -#endif - -// The following use the helper classes -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_boolean x) -{ - (void) os.write_boolean (x.val_); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_char x) -{ - os.write_char (x.val_); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_wchar x) -{ - os.write_wchar (x.val_); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_octet x) -{ - os.write_octet (x.val_); - return (ACE_CDR::Boolean) os.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_string x) -{ - ACE_CDR::ULong len = 0; - - if (x.val_ != 0) - { - len = static_cast (ACE_OS::strlen (x.val_)); - } - - os.write_string (len, x.val_); - return - (ACE_CDR::Boolean) (os.good_bit () && (!x.bound_ || len <= x.bound_)); -} - -ACE_INLINE ACE_CDR::Boolean -operator<< (ACE_OutputCDR &os, ACE_OutputCDR::from_wstring x) -{ - ACE_CDR::ULong len = 0; - - if (x.val_ != 0) - { - len = static_cast (ACE_OS::strlen (x.val_)); - } - - os.write_wstring (len, x.val_); - return - (ACE_CDR::Boolean) (os.good_bit () && (!x.bound_ || len <= x.bound_)); -} - -// **************************************************************** - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_CDR::Char &x) -{ - return is.read_char (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_CDR::Short &x) -{ - return is.read_short (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_CDR::UShort &x) -{ - return is.read_ushort (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>>(ACE_InputCDR &is, ACE_CDR::Long &x) -{ - return is.read_long (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_CDR::ULong &x) -{ - return is.read_ulong (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR& is, ACE_CDR::LongLong &x) -{ - return is.read_longlong (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR& is, ACE_CDR::ULongLong &x) -{ - return is.read_ulonglong (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR& is, ACE_CDR::LongDouble &x) -{ - return is.read_longdouble (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_CDR::Float &x) -{ - return is.read_float (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_CDR::Double &x) -{ - return is.read_double (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_CDR::Fixed &x) -{ - return is.read_fixed (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_CDR::Char *&x) -{ - return is.read_string (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_CDR::WChar *&x) -{ - return is.read_wstring (x) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, std::string& x) -{ - return is.read_string (x) && is.good_bit (); -} - -#if !defined(ACE_LACKS_STD_WSTRING) -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, std::wstring& x) -{ - return is.read_wstring (x) && is.good_bit (); -} -#endif - -// The following use the helper classes -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_InputCDR::to_boolean x) -{ - return is.read_boolean (x.ref_); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_InputCDR::to_char x) -{ - return is.read_char (x.ref_) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_InputCDR::to_wchar x) -{ - return is.read_wchar (x.ref_) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_InputCDR::to_octet x) -{ - return is.read_octet (x.ref_) && is.good_bit (); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_InputCDR::to_string x) -{ - // check if the bounds are satisfied - return - (is.read_string (const_cast (x.val_)) - && is.good_bit () - && (!x.bound_ - || ACE_OS::strlen (x.val_) <= x.bound_)); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_InputCDR::to_wstring x) -{ - // check if the bounds are satisfied - return - (is.read_wstring (const_cast (x.val_)) - && is.good_bit () - && (!x.bound_ - || ACE_OS::strlen (x.val_) <= x.bound_)); -} - -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_InputCDR::to_std_string x) -{ - // check if the bounds are satisfied - return - (is.read_string (x.val_) - && is.good_bit () - && (!x.bound_ - || static_cast (x.val_.size ()) <= x.bound_)); -} - -#if !defined(ACE_LACKS_STD_WSTRING) -ACE_INLINE ACE_CDR::Boolean -operator>> (ACE_InputCDR &is, ACE_InputCDR::to_std_wstring x) -{ - // check if the bounds are satisfied - return - (is.read_wstring (x.val_) - && is.good_bit () - && (!x.bound_ - || static_cast (x.val_.size ()) <= x.bound_)); -} -#endif -// *************************************************************************** -// We must define these methods here because they use the "read_*" inlined -// methods of the ACE_InputCDR class -// *************************************************************************** - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_boolean (ACE_InputCDR &stream) -{ - ACE_CDR::Boolean x; - return stream.read_boolean (x) ? this->write_boolean (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_char (ACE_InputCDR &stream) -{ - ACE_CDR::Char x; - return stream.read_char (x) ? this->write_char (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_wchar (ACE_InputCDR &stream) -{ - ACE_CDR::WChar x; - return stream.read_wchar (x) ? this->write_wchar (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_octet (ACE_InputCDR &stream) -{ - ACE_CDR::Octet x; - return stream.read_octet (x) ? this->write_octet (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_short (ACE_InputCDR &stream) -{ - ACE_CDR::Short x; - return stream.read_short (x) ? this->write_short (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_ushort (ACE_InputCDR &stream) -{ - ACE_CDR::UShort x; - return stream.read_ushort (x) ? this->write_ushort (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_long (ACE_InputCDR &stream) -{ - ACE_CDR::Long x; - return stream.read_long (x) ? this->write_long (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_ulong (ACE_InputCDR &stream) -{ - ACE_CDR::ULong x; - return stream.read_ulong (x) ? this->write_ulong (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_longlong (ACE_InputCDR &stream) -{ - ACE_CDR::LongLong x; - return stream.read_longlong (x) ? this->write_longlong (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_ulonglong (ACE_InputCDR &stream) -{ - ACE_CDR::ULongLong x; - return stream.read_ulonglong (x) ? this->write_ulonglong (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_float (ACE_InputCDR &stream) -{ - ACE_CDR::Float x; - return stream.read_float (x) ? this->write_float (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_double (ACE_InputCDR &stream) -{ - ACE_CDR::Double x; - return stream.read_double (x) ? this->write_double (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_longdouble (ACE_InputCDR &stream) -{ - ACE_CDR::LongDouble x; - return stream.read_longdouble (x) ? this->write_longdouble (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_fixed (ACE_InputCDR &stream) -{ - ACE_CDR::Fixed x; - return stream.read_fixed (x) ? this->write_fixed (x) : false; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_string (ACE_InputCDR &stream) -{ - ACE_CDR::Char *x = 0; - ACE_CDR::Boolean const flag = - (stream.read_string (x) ? this->write_string (x) : false); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(x); -#else - delete [] x; -#endif /* ACE_HAS_ALLOC_HOOKS */ - return flag; -} - -ACE_INLINE ACE_CDR::Boolean -ACE_OutputCDR::append_wstring (ACE_InputCDR &stream) -{ - ACE_CDR::WChar *x = 0; - ACE_CDR::Boolean const flag = - (stream.read_wstring (x) ? this->write_wstring (x) : false); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(x); -#else - delete [] x; -#endif /* ACE_HAS_ALLOC_HOOKS */ - return flag; -} - -ACE_INLINE void -ACE_InputCDR::reset_byte_order (int byte_order) -{ - this->do_byte_swap_ = (byte_order != ACE_CDR_BYTE_ORDER); -} - -ACE_INLINE bool -ACE_InputCDR::do_byte_swap (void) const -{ - return this->do_byte_swap_; -} - -ACE_INLINE int -ACE_InputCDR::byte_order (void) const -{ - return this->do_byte_swap () ? !ACE_CDR_BYTE_ORDER : ACE_CDR_BYTE_ORDER; -} - -ACE_INLINE int -ACE_InputCDR::align_read_ptr (size_t alignment) -{ -#if !defined (ACE_LACKS_CDR_ALIGNMENT) - char *buf = ACE_ptr_align_binary (this->rd_ptr (), - alignment); -#else - char *buf = this->rd_ptr (); -#endif /* ACE_LACKS_CDR_ALIGNMENT */ - - if (buf <= this->wr_ptr ()) - { - this->start_.rd_ptr (buf); - return 0; - } - - this->good_bit_ = false; - return -1; -} - -ACE_INLINE void -ACE_InputCDR::set_version (ACE_CDR::Octet major, ACE_CDR::Octet minor) -{ - this->major_version_ = major; - this->minor_version_ = minor; -} - -ACE_INLINE void -ACE_InputCDR::get_version (ACE_CDR::Octet &major, ACE_CDR::Octet &minor) -{ - major = this->major_version_; - minor = this->minor_version_; -} - -ACE_INLINE ACE_Char_Codeset_Translator * -ACE_InputCDR::char_translator (void) const -{ - return this->char_translator_; -} - -ACE_INLINE ACE_WChar_Codeset_Translator * -ACE_InputCDR::wchar_translator (void) const -{ - return this->wchar_translator_; -} - - -ACE_INLINE void -ACE_InputCDR::char_translator (ACE_Char_Codeset_Translator * ctran) -{ - this->char_translator_ = ctran; -} - -ACE_INLINE void -ACE_InputCDR::wchar_translator (ACE_WChar_Codeset_Translator * wctran) -{ - this->wchar_translator_ = wctran; -} - -// **************************************************************** - -ACE_INLINE ACE_CDR::Boolean -ACE_Char_Codeset_Translator::read_1 (ACE_InputCDR& input, - ACE_CDR::Octet *x) -{ - return input.read_1 (x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_Char_Codeset_Translator::write_1 (ACE_OutputCDR& output, - const ACE_CDR::Octet *x) -{ - return output.write_1 (x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_Char_Codeset_Translator::read_array (ACE_InputCDR& in, - void* x, - size_t size, - size_t align, - ACE_CDR::ULong length) -{ - return in.read_array (x, size, align, length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_Char_Codeset_Translator::write_array (ACE_OutputCDR& out, - const void *x, - size_t size, - size_t align, - ACE_CDR::ULong length) -{ - return out.write_array(x, size, align, length); -} - -ACE_INLINE int -ACE_Char_Codeset_Translator::adjust (ACE_OutputCDR& out, - size_t size, - size_t align, - char *&buf) -{ - return out.adjust(size, align, buf); -} - -ACE_INLINE void -ACE_Char_Codeset_Translator::good_bit (ACE_OutputCDR& out, bool bit) -{ - out.good_bit_ = bit; -} - -ACE_INLINE ACE_CDR::Octet -ACE_Char_Codeset_Translator::major_version (ACE_InputCDR& input) -{ - return input.major_version_; -} - -ACE_INLINE ACE_CDR::Octet -ACE_Char_Codeset_Translator::minor_version (ACE_InputCDR& input) -{ - return input.minor_version_; -} - -ACE_INLINE ACE_CDR::Octet -ACE_Char_Codeset_Translator::major_version (ACE_OutputCDR& output) -{ - return output.major_version_; -} - -ACE_INLINE ACE_CDR::Octet -ACE_Char_Codeset_Translator::minor_version (ACE_OutputCDR& output) -{ - return output.minor_version_; -} - -// **************************************************************** - -ACE_INLINE ACE_CDR::Boolean -ACE_WChar_Codeset_Translator::read_1 (ACE_InputCDR& input, - ACE_CDR::Octet *x) -{ - return input.read_1 (x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_WChar_Codeset_Translator::read_2 (ACE_InputCDR& input, - ACE_CDR::UShort *x) -{ - return input.read_2 (x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_WChar_Codeset_Translator::read_4 (ACE_InputCDR& input, - ACE_CDR::ULong *x) -{ - return input.read_4 (x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_WChar_Codeset_Translator::write_1 (ACE_OutputCDR& output, - const ACE_CDR::Octet *x) -{ - return output.write_1 (x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_WChar_Codeset_Translator::write_2 (ACE_OutputCDR& output, - const ACE_CDR::UShort *x) -{ - return output.write_2 (x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_WChar_Codeset_Translator::write_4 (ACE_OutputCDR& output, - const ACE_CDR::ULong *x) -{ - return output.write_4 (x); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_WChar_Codeset_Translator::read_array (ACE_InputCDR& in, - void* x, - size_t size, - size_t align, - ACE_CDR::ULong length) -{ - return in.read_array (x, size, align, length); -} - -ACE_INLINE ACE_CDR::Boolean -ACE_WChar_Codeset_Translator::write_array (ACE_OutputCDR& out, - const void *x, - size_t size, - size_t align, - ACE_CDR::ULong length) -{ - return out.write_array(x, size, align, length); -} - -ACE_INLINE int -ACE_WChar_Codeset_Translator::adjust (ACE_OutputCDR& out, - size_t size, - size_t align, - char *&buf) -{ - return out.adjust(size, align, buf); -} - -ACE_INLINE void -ACE_WChar_Codeset_Translator::good_bit (ACE_OutputCDR& out, bool bit) -{ - out.good_bit_ = bit; -} - -ACE_INLINE ACE_CDR::Octet -ACE_WChar_Codeset_Translator::major_version (ACE_InputCDR& input) -{ - return input.major_version_; -} - -ACE_INLINE ACE_CDR::Octet -ACE_WChar_Codeset_Translator::minor_version (ACE_InputCDR& input) -{ - return input.minor_version_; -} - -ACE_INLINE ACE_CDR::Octet -ACE_WChar_Codeset_Translator::major_version (ACE_OutputCDR& output) -{ - return output.major_version_; -} - -ACE_INLINE ACE_CDR::Octet -ACE_WChar_Codeset_Translator::minor_version (ACE_OutputCDR& output) -{ - return output.minor_version_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/CE_Screen_Output.cpp b/deps/acelite/ace/CE_Screen_Output.cpp deleted file mode 100644 index 8711f1e57..000000000 --- a/deps/acelite/ace/CE_Screen_Output.cpp +++ /dev/null @@ -1,156 +0,0 @@ -#include "ace/CE_Screen_Output.h" -#if defined (ACE_HAS_WINCE) - -#include "ace/Log_Category.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_CE_Screen_Output::ACE_CE_Screen_Output(HWND hEdit) -: handler_(hEdit) -, pFile_(0) -{ -} - -ACE_CE_Screen_Output::ACE_CE_Screen_Output() -: handler_(0) -, pFile_(0) -{ -} - -ACE_CE_Screen_Output::~ACE_CE_Screen_Output() -{ - if (pFile_ != 0) { - fclose(pFile_); - } -} - -void ACE_CE_Screen_Output::log(ACE_Log_Record &log_record) -{ - ACE_TCHAR verbose_msg[ACE_Log_Record::MAXVERBOSELOGMSGLEN]; - int result = log_record.format_msg (ACE_TEXT("WindozeCE"), // host name - 0, // verbose flag - verbose_msg); - - if (result == 0) - { - verbose_msg[ ACE_OS::strlen(verbose_msg) - 1 ] = 0; // CE does not like '\n' by itself. - *this << verbose_msg << endl; - } -} - -void ACE_CE_Screen_Output::SetOutputWindow(HWND hEdit) -{ - handler_ = hEdit; -} - -void ACE_CE_Screen_Output::clear() -{ - SetWindowText(handler_, 0); -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (ACE_TCHAR* output) -{ - int length = GetWindowTextLength(handler_); - SendMessage(handler_, EM_SETSEL, length, length); - SendMessage(handler_, EM_REPLACESEL, 0, (LPARAM)output); - - if (pFile_ != 0) - { - fwprintf(pFile_, L"%s", output); - } - - return *this; -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (const ACE_TCHAR* output) -{ - ACE_TCHAR* buffer = ACE_OS::strdup(output); - if (buffer != 0) - { - *this << buffer; - delete buffer; - } - return *this; -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (ACE_ANTI_TCHAR* output) -{ - *this << ACE_TEXT_CHAR_TO_TCHAR(output); - return *this; -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (const ACE_ANTI_TCHAR* output) -{ - *this << ACE_TEXT_CHAR_TO_TCHAR(output); - return *this; -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (char output) -{ - *this << (int)output; - return *this; -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (unsigned char output) -{ - *this << (int)output; - return *this; -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (unsigned short output) -{ - ACE_TCHAR buffer[20]; - wsprintf(buffer, ACE_TEXT("%u"), output); - *this << buffer; - return *this; -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (int output) -{ - ACE_TCHAR buffer[20]; - wsprintf(buffer, ACE_TEXT("%d"), output); - *this << buffer; - return *this; -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (unsigned int output) -{ - ACE_TCHAR buffer[20]; - wsprintf(buffer, ACE_TEXT("%du"), output); - *this << buffer; - return *this; -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (float output) -{ - ACE_TCHAR buffer[20]; - swprintf(buffer, ACE_TEXT("%f"), output); - *this << buffer; - return *this; -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (long output) -{ - ACE_TCHAR buffer[20]; - wsprintf(buffer, ACE_TEXT("%l"), output); - *this << buffer; - return *this; -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (unsigned long output) -{ - ACE_TCHAR buffer[20]; - wsprintf(buffer, ACE_TEXT("%lu"), output); - *this << buffer; - return *this; -} - -ACE_CE_Screen_Output& ACE_CE_Screen_Output::operator << (FILE* pFile) -{ - pFile_ = pFile; - return *this; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif // ACE_HAS_WINCE diff --git a/deps/acelite/ace/CE_Screen_Output.h b/deps/acelite/ace/CE_Screen_Output.h deleted file mode 100644 index f2497487d..000000000 --- a/deps/acelite/ace/CE_Screen_Output.h +++ /dev/null @@ -1,104 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file CE_Screen_Output.h - * - * @author Si Mong Park - */ -//============================================================================= - -#ifndef ACE_CE_SCREEN_OUTPUT_H -#define ACE_CE_SCREEN_OUTPUT_H - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_WINCE) - -#include "ace/Log_Msg_Callback.h" -#include "ace/Log_Record.h" - -namespace -{ - const ACE_TCHAR endl[] = ACE_TEXT("\r\n"); - const ACE_TCHAR tab[] = ACE_TEXT("\t"); -} - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_CE_Screen_Output - * - * @brief Replacement of text output for Windows CE. - * - * This class allows standard text output to be displayed on - * text window for Windows CE. Generally, all ACE output will - * go through under CE if and only if user uses Windows CE - * implementation by using main_ce instead of main. - * Also, for the easier debugging purpose, object pointer of - * this class can be gotten from ACE_Log_Msg::msg_callback() - * and then can be used directly by user just like cout stream. - */ -class ACE_Export ACE_CE_Screen_Output : public ACE_Log_Msg_Callback -{ -public: - ACE_CE_Screen_Output (HWND hEdit); - - ACE_CE_Screen_Output (void); - - virtual ~ACE_CE_Screen_Output(); - - /// Implementation of pure virtual function from ACE_Log_Msg_Callback. - virtual void log (ACE_Log_Record &log_record); - - /// Interface to specify active window handle. - void SetOutputWindow (HWND hWnd); - - void clear (void); - - /// Stream insertion operator that performs actual print out. - /** - * @note This is the only one operator that performs output. All - * other perators convert the type and use this operator - * underneath. - */ - ACE_CE_Screen_Output& operator << (ACE_TCHAR*); - ACE_CE_Screen_Output& operator << (const ACE_TCHAR*); - - ACE_CE_Screen_Output& operator << (ACE_ANTI_TCHAR* output); - ACE_CE_Screen_Output& operator << (const ACE_ANTI_TCHAR* output); - - ACE_CE_Screen_Output& operator << (char output); - ACE_CE_Screen_Output& operator << (unsigned char output); - - ACE_CE_Screen_Output& operator << (unsigned short output); - - ACE_CE_Screen_Output& operator << (int output); - ACE_CE_Screen_Output& operator << (unsigned int output); - - ACE_CE_Screen_Output& operator << (float output); - - ACE_CE_Screen_Output& operator << (long output); - ACE_CE_Screen_Output& operator << (unsigned long output); - - ACE_CE_Screen_Output& operator << (FILE* pFile); - -private: - ACE_CE_Screen_Output (ACE_CE_Screen_Output&); - -private: - HWND handler_; - - /// FILE pointer that used to save output to file. This class does - /// not own the file handler pointer. - FILE* pFile_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif // ACE_HAS_WINCE -#endif // ACE_CE_SCREEN_OUTPUT_H diff --git a/deps/acelite/ace/CORBA_macros.h b/deps/acelite/ace/CORBA_macros.h deleted file mode 100644 index 9cd55e26d..000000000 --- a/deps/acelite/ace/CORBA_macros.h +++ /dev/null @@ -1,88 +0,0 @@ -// -*- C++ -*- - -// ============================================================================ -/** - * @file CORBA_macros.h - * - * Writing code that is portable between platforms with or without - * native C++ exceptions is hard. The following macros offer some - * help on this task, mostly oriented to making the ORB code and the - * IDL generated code portable. - * - * @author Nanbor Wang - * @author Aniruddha Gokhale - * @author Carlos O'Ryan , et al. - */ -// ============================================================================ - -// Macros for handling CORBA exceptions. - -#ifndef ACE_CORBA_MACROS_H -#define ACE_CORBA_MACROS_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -# if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -# endif /* ACE_LACKS_PRAGMA_ONCE */ - -// The Windows MFC exception mechanism requires that a caught CException -// (including the CMemoryException in use here) be freed using its Delete() -// method. Thus, when MFC is in use and we're catching exceptions as a result -// of new(), the exception's Delete() method has to be called. No other -// platform imposes this sort of restriction/requirement. The Windows -// config stuff (at least for MSVC/MFC) defines a ACE_del_bad_alloc macro -// that works with its ACE_bad_alloc macro to implement this cleanup -// requirement. Since no other platform requires this, define it as -// empty here. -#if !defined (ACE_del_bad_alloc) -# define ACE_del_bad_alloc -#endif - -// ACE_HAS_EXCEPTIONS is not the same as ACE_NEW_THROWS_EXCEPTIONS. -#if defined(ACE_NEW_THROWS_EXCEPTIONS) - -# if defined (ACE_HAS_NEW_NOTHROW) - -# define ACE_NEW_THROW_EX(POINTER,CONSTRUCTOR,EXCEPTION) \ - do { POINTER = new (ACE_nothrow) CONSTRUCTOR; \ - if (POINTER == 0) { throw EXCEPTION; } \ - } while (0) - -# else - -# define ACE_NEW_THROW_EX(POINTER,CONSTRUCTOR,EXCEPTION) \ - do { try { POINTER = new CONSTRUCTOR; } \ - catch (ACE_bad_alloc) { ACE_del_bad_alloc throw EXCEPTION; } \ - } while (0) - -# endif /* ACE_HAS_NEW_NOTHROW */ - -#else /* ! ACE_NEW_THROWS_EXCEPTIONS */ - -# define ACE_NEW_THROW_EX(POINTER,CONSTRUCTOR,EXCEPTION) \ - do { POINTER = new CONSTRUCTOR; \ - if (POINTER == 0) { throw EXCEPTION; } \ - } while (0) - -#endif /* ACE_NEW_THROWS_EXCEPTIONS */ - -// FUZZ: disable check_for_ACE_Guard -# define ACE_GUARD_THROW_EX(MUTEX,OBJ,LOCK,EXCEPTION) \ - ACE_Guard< MUTEX > OBJ (LOCK); \ - if (OBJ.locked () == 0) throw EXCEPTION; - -# define ACE_READ_GUARD_THROW_EX(MUTEX,OBJ,LOCK,EXCEPTION) \ - ACE_Read_Guard< MUTEX > OBJ (LOCK); \ - if (OBJ.locked () == 0) throw EXCEPTION; - -# define ACE_WRITE_GUARD_THROW_EX(MUTEX,OBJ,LOCK,EXCEPTION) \ - ACE_Write_Guard< MUTEX > OBJ (LOCK); \ - if (OBJ.locked () == 0) throw EXCEPTION; -// FUZZ: enable check_for_ACE_Guard - -#include /**/ "ace/post.h" - -#endif /* ACE_CORBA_MACROS_H */ diff --git a/deps/acelite/ace/Cache_Map_Manager_T.cpp b/deps/acelite/ace/Cache_Map_Manager_T.cpp deleted file mode 100644 index b92876a7f..000000000 --- a/deps/acelite/ace/Cache_Map_Manager_T.cpp +++ /dev/null @@ -1,410 +0,0 @@ -#ifndef ACE_CACHE_MAP_MANAGER_T_CPP -#define ACE_CACHE_MAP_MANAGER_T_CPP - -#include "ace/Cache_Map_Manager_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Log_Category.h" -#include "ace/Malloc_Base.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Cache_Map_Manager_T.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc7(ACE_Cache_Map_Manager) -ACE_ALLOC_HOOK_DEFINE_Tc5(ACE_Cache_Map_Iterator) -ACE_ALLOC_HOOK_DEFINE_Tc5(ACE_Cache_Map_Reverse_Iterator) - -template -ACE_Cache_Map_Manager::ACE_Cache_Map_Manager (CACHING_STRATEGY &caching_s, - size_t size, - ACE_Allocator *alloc) - : caching_strategy_ (caching_s) -{ - if (this->open (size, alloc) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Cache_Map_Manager::ACE_Cache_Map_Manager"))); - -} - -template -ACE_Cache_Map_Manager::~ACE_Cache_Map_Manager (void) -{ - this->close (); -} - -template int -ACE_Cache_Map_Manager::open (size_t length, - ACE_Allocator *alloc) -{ - return this->map_.open (length, - alloc); -} - -template int -ACE_Cache_Map_Manager::close (void) -{ - return this->map_.close (); -} - -template int -ACE_Cache_Map_Manager::bind (const KEY &key, - const VALUE &value) -{ - // Insert an entry which has the and the which - // is the combination of the and the attributes of the - // caching strategy. - CACHE_VALUE cache_value (value, - this->caching_strategy_.attributes ()); - - int bind_result = this->map_.bind (key, - cache_value); - - if (bind_result != -1) - { - - int result = this->caching_strategy_.notify_bind (bind_result, - cache_value.second); - - if (result == -1) - { - - this->map_.unbind (key); - - // Unless the notification goes thru the bind operation is - // not complete. - bind_result = -1; - - } - - } - - return bind_result; -} - - -template int -ACE_Cache_Map_Manager::rebind (const KEY &key, - const VALUE &value) -{ - CACHE_VALUE cache_value (value, - this->caching_strategy_.attributes ()); - - int rebind_result = this->map_.rebind (key, - cache_value); - - if (rebind_result != -1) - { - - int result = this->caching_strategy_.notify_rebind (rebind_result, - cache_value.second ()); - - if (result == -1) - { - - // Make sure the unbind operation is done only when the - // notification fails after a bind which is denoted by - // rebind_result = 0 - if (rebind_result == 0) - this->map_.unbind (key); - - // Unless the notification goes thru the rebind operation is - // not complete. - rebind_result = -1; - - } - - } - - return rebind_result; -} - - -template int -ACE_Cache_Map_Manager::rebind (const KEY &key, - const VALUE &value, - VALUE &old_value) -{ - CACHE_VALUE cache_value (value, - this->caching_strategy_.attributes ()); - - CACHE_VALUE old_cache_value (old_value, - this->caching_strategy_.attributes ()); - - int rebind_result = this->map_.rebind (key, - cache_value, - old_cache_value); - - if (rebind_result != -1) - { - - int result = this->caching_strategy_.notify_rebind (rebind_result, - cache_value.second ()); - - if (result == -1) - { - - // Make sure the unbind operation is done only when the - // notification fails after a bind which is denoted by - // rebind_result = 0 - if (rebind_result == 0) - this->map_.unbind (key); - - // Unless the notification goes thru the rebind operation is - // not complete. - rebind_result = -1; - - } - else - { - - old_value = old_cache_value.first (); - - } - - } - - return rebind_result; -} - -template int -ACE_Cache_Map_Manager::rebind (const KEY &key, - const VALUE &value, - KEY &old_key, - VALUE &old_value) -{ - CACHE_VALUE cache_value (value, - this->caching_strategy_.attributes ()); - - CACHE_VALUE old_cache_value (old_value, - this->caching_strategy_.attributes ()); - - int rebind_result = this->map_.rebind (key, - cache_value, - old_key, - old_cache_value); - - if (rebind_result != -1) - { - - int result = this->caching_strategy_.notify_rebind (rebind_result, - cache_value.second ()); - - if (result == -1) - { - - // Make sure the unbind operation is done only when the - // notification fails after a bind which is denoted by - // rebind_result = 0 - if (rebind_result == 0) - this->map_.unbind (key); - - // Unless the notification goes thru the rebind operation is - // not complete. - rebind_result = -1; - - } - else - { - - old_value = old_cache_value.first (); - - } - - } - - return rebind_result; -} - -template int -ACE_Cache_Map_Manager::trybind (const KEY &key, - VALUE &value) -{ - CACHE_VALUE cache_value (value, - this->caching_strategy_.attributes ()); - - int trybind_result = this->map_.trybind (key, - cache_value); - - if (trybind_result != -1) - { - - int result = this->caching_strategy_.notify_trybind (trybind_result, - cache_value.second ()); - - if (result == -1) - { - - // If the entry has got inserted into the map, it is removed - // due to failure. - if (trybind_result == 0) - this->map_.unbind (key); - - trybind_result = -1; - - } - else - { - - // If an attempt is made to bind an existing entry the value - // is overwritten with the value from the map. - if (trybind_result == 1) - value = cache_value.first (); - - } - - } - - return trybind_result; -} - -template int -ACE_Cache_Map_Manager::find (const KEY &key, - VALUE &value) -{ - // Lookup the key and populate the . - CACHE_VALUE cache_value; - - int find_result = this->map_.find (key, - cache_value); - - if (find_result != -1) - { - - int result = this->caching_strategy_.notify_find (find_result, - cache_value.second); - - // Unless the find and notification operations go thru, this - // method is not successful. - if (result == -1) - find_result = -1; - else - { - - // Since the has now changed after the - // notification, we need to bind to the map again. - int rebind_result = this->map_.rebind (key, - cache_value); - if (rebind_result == -1) - find_result = -1; - else - value = cache_value.first; - - } - - } - - return find_result; -} - -template int -ACE_Cache_Map_Manager::find (const KEY &key) -{ - // Lookup the key and populate the . - CACHE_VALUE cache_value; - - int find_result = this->map_.find (key, - cache_value); - - if (find_result != -1) - { - - int result = this->caching_strategy_.notify_find (find_result, - cache_value.second); - - // Unless the find and notification operations go thru, this - // method is not successful. - if (result == -1) - find_result = -1; - else - { - - // Since the has now changed after the - // notification, we need to bind to the map again. - int rebind_result = this->map_.rebind (key, - cache_value); - - if (rebind_result == -1) - find_result = -1; - - } - - } - - return find_result; -} - - -template int -ACE_Cache_Map_Manager::unbind (const KEY &key) -{ - // Remove the entry from the cache. - CACHE_VALUE cache_value; - - int unbind_result = this->map_.unbind (key, - cache_value); - - if (unbind_result != -1) - { - - int result = this->caching_strategy_.notify_unbind (unbind_result, - cache_value.second); - - if (result == -1) - unbind_result = -1; - - } - - return unbind_result; -} - -template int -ACE_Cache_Map_Manager::unbind (const KEY &key, - VALUE &value) -{ - // Remove the entry from the cache. - CACHE_VALUE cache_value; - - int unbind_result = this->map_.unbind (key, - cache_value); - - if (unbind_result != -1) - { - - int result = this->caching_strategy_.notify_unbind (unbind_result, - cache_value.second ()); - - if (result == -1) - unbind_result = -1; - else - value = cache_value.first (); - - } - - return unbind_result; -} - -template void -ACE_Cache_Map_Manager::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - this->map_.dump (); - - this->caching_strategy_.dump (); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Cache_Map_Iterator::~ACE_Cache_Map_Iterator (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_CACHE_MAP_MANAGER_T_CPP */ diff --git a/deps/acelite/ace/Cache_Map_Manager_T.h b/deps/acelite/ace/Cache_Map_Manager_T.h deleted file mode 100644 index da181cb0e..000000000 --- a/deps/acelite/ace/Cache_Map_Manager_T.h +++ /dev/null @@ -1,398 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Cache_Map_Manager_T.h - * - * @author Kirthika Parameswaran - */ -//============================================================================= - -#ifndef ACE_CACHE_MAP_MANAGER_T_H -#define ACE_CACHE_MAP_MANAGER_T_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Default_Constants.h" -#include "ace/Global_Macros.h" -#include "ace/Pair_T.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward declaration. -class ACE_Allocator; - -#define ACE_Cache_Map_Iterator ACMI -#define ACE_Cache_Map_Reverse_Iterator ACMRI - -template -class ACE_Cache_Map_Iterator; - -template -class ACE_Cache_Map_Reverse_Iterator; - -// For linkers that cant grok long names. -#define ACE_Cache_Map_Manager ACMM - -/** - * @class ACE_Cache_Map_Manager - * - * @brief Defines a abstraction that will purge entries from a map. - * - * The will manage the map it contains - * and provide purging on demand from the map. The strategy for - * caching is decided by the user and provided to the Cache - * Manager. The Cache Manager acts as a agent and communicates - * between the Map and the Strategy for purging entries from the - * map. - * No locking mechanism provided since locking at this level - * isn't efficient. Locking has to be provided by the - * application. - */ -template -class ACE_Cache_Map_Manager -{ -public: - // = Traits. - typedef KEY key_type; - typedef VALUE mapped_type; - typedef CMAP_TYPE map_type; - typedef CACHING_STRATEGY caching_strategy_type; - - typedef ITERATOR_IMPL ITERATOR_IMPLEMENTATION; - typedef REVERSE_ITERATOR_IMPL REVERSE_ITERATOR_IMPLEMENTATION; - - friend class ACE_Cache_Map_Iterator; - friend class ACE_Cache_Map_Reverse_Iterator; - - // = ACE-style iterator typedefs. - typedef ACE_Cache_Map_Iterator - ITERATOR; - typedef ACE_Cache_Map_Reverse_Iterator - REVERSE_ITERATOR; - - // = STL-style iterator typedefs. - typedef ITERATOR - iterator; - typedef REVERSE_ITERATOR - reverse_iterator; - - /** - * The actual value mapped to the key in the map. The - * are used by the strategy and is transparent to the user of this - * class. - */ - typedef std::pair CACHE_VALUE; - - /// Initialize a with and - /// @a size entries. - ACE_Cache_Map_Manager (CACHING_STRATEGY &caching_strategy, - size_t size = ACE_DEFAULT_MAP_SIZE, - ACE_Allocator *alloc = 0); - - /// Close down a and release dynamically allocated - /// resources. - virtual ~ACE_Cache_Map_Manager (void); - - /// Initialize a cache with size @a length. - int open (size_t length = ACE_DEFAULT_MAP_SIZE, - ACE_Allocator *alloc = 0); - - /// Close down a cache and release dynamically allocated resources. - int close (void); - - /** - * Associate @a key with @a value. If @a key is already in the CMAP_TYPE - * then the ENTRY is not changed. Returns 0 if a new entry is bound - * successfully, returns 1 if an attempt is made to bind an existing - * entry, and returns -1 if failures occur. - */ - int bind (const KEY &key, - const VALUE &value); - - /** - * Lookup entry in the cache. If it is not found, returns -1. - * If the @a key is located in the CMAP_TYPE object, the CACHING_STRATEGY is - * notified of it via notify_find (int result, ATTRIBUTES &attribute). - * If notify_find also returns 0 (success), then this function returns - * 0 (success) and sets the cached value in @a value. - */ - int find (const KEY &key, - VALUE &value); - - /** - * Lookup entry in the cache. If it is not found, returns -1. - * If the @a key is located in the CMAP_TYPE object, the CACHING_STRATEGY is - * notified of it via notify_find (int result, ATTRIBUTES &attribute). - * If notify_find also returns 0 (success), then this function returns - * 0 (success). - */ - int find (const KEY &key); - - /** - * Reassociate the @a key with @a value. If the @a key already exists - * in the cache then returns 1, on a new bind returns 0 and returns - * -1 in case of any failures. - */ - int rebind (const KEY &key, - const VALUE &value); - - /** - * Reassociate @a key with @a value, storing the old value into the - * "out" parameter @a old_value. The function fails if @a key is not - * in the cache for caches that do not allow user specified keys. - * However, for caches that allow user specified keys, if the key is - * not in the cache, a new @a key / @a value association is created. - */ - int rebind (const KEY &key, - const VALUE &value, - VALUE &old_value); - - /** - * Reassociate @a key with @a value, storing the old key and value - * into the "out" parameters @a old_key and @a old_value. The - * function fails if @a key is not in the cache for caches that do - * not allow user specified keys. However, for caches that allow - * user specified keys, if the key is not in the cache, a new - * @a key / @a value association is created. - */ - int rebind (const KEY &key, - const VALUE &value, - KEY &old_key, - VALUE &old_value); - - /** - * Associate @a key with @a value if and only if @a key is not in the - * cache. If @a key is already in the cache, then the @a value - * parameter is overwritten with the existing value in the - * cache. Returns 0 if a new @a key / @a value association is created. - * Returns 1 if an attempt is made to bind an existing entry. This - * function fails for maps that do not allow user specified keys. - */ - int trybind (const KEY &key, - VALUE &value); - - /// Remove @a key from the cache. - int unbind (const KEY &key); - - /// Remove @a key from the cache, and return the @a value associated with - /// @a key. - int unbind (const KEY &key, - VALUE &value); - - /// Remove entries from the cache depending upon the strategy. - int purge (void); - - /// Return the current size of the cache. - size_t current_size (void) const; - - /// Return the total size of the cache. - size_t total_size (void) const; - - /// Dumps the state of the object. - void dump (void) const; - - // = STL styled iterator factory functions. - - /// Return forward iterator. - ITERATOR begin (void); - ITERATOR end (void); - - /// Return reverse iterator. - REVERSE_ITERATOR rbegin (void); - REVERSE_ITERATOR rend (void); - - /// The map managed by the Cache_Map_Manager. - CMAP_TYPE &map (void); - - /// The caching strategy used on the cache. - CACHING_STRATEGY &caching_strategy (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - - /// The underlying map which needs to be cached. - CMAP_TYPE map_; - - /// The strategy to be followed for caching entries in the map. - CACHING_STRATEGY &caching_strategy_; - -private: - // = Disallow these operations. - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Cache_Map_Manager &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Cache_Map_Manager (const ACE_Cache_Map_Manager &)) -}; - -/** - * @class ACE_Cache_Map_Iterator - * - * @brief Defines a iterator for the Cache_Map_Manager. - * - * Implementation to be provided by the iterator of the map - * managed by the ACE_Cache_Map_Manager. - */ -template -class ACE_Cache_Map_Iterator -{ -public: - // = Traits. - /// The actual value mapped to the key in the cache. The - /// are used by the strategy and is transparent to the cache user. - typedef ACE_Reference_Pair - value_type; - typedef std::pair - CACHE_VALUE; - - // = Initialisation and termination methods. - - ACE_Cache_Map_Iterator (const IMPLEMENTATION &iterator_impl); - - /// Copy constructor. - ACE_Cache_Map_Iterator (const ACE_Cache_Map_Iterator &rhs); - - virtual ~ACE_Cache_Map_Iterator (void); - - // = Iteration methods. - - /// assignment operator. - ACE_Cache_Map_Iterator &operator= - (const ACE_Cache_Map_Iterator &rhs); - - /// Comparison operators. - bool operator== (const ACE_Cache_Map_Iterator &rhs) const; - bool operator!= (const ACE_Cache_Map_Iterator &rhs) const; - - /// Returns a reference to the internal element @c this is pointing - /// to. - ACE_Reference_Pair operator* (void) const; - - // = STL styled iteration, compare, and reference functions. - - /// Prefix advance - ACE_Cache_Map_Iterator &operator++ (void); - - /// Postfix advance. - ACE_Cache_Map_Iterator operator++ (int); - - /// Prefix reverse. - ACE_Cache_Map_Iterator &operator-- (void); - - /// Postfix reverse. - ACE_Cache_Map_Iterator operator-- (int); - - /// Returns the iterator of the internal map in the custody of the - /// Cache_Map_Manager. - IMPLEMENTATION &iterator_implementation (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// The actual iterator which iterates internally on the map - /// belonging to the Cache_Map_Manager. - IMPLEMENTATION iterator_implementation_; -}; - -/** - * @class ACE_Cache_Map_Reverse_Iterator - * - * @brief Defines a reverse iterator for the Cache_Map_Manager. - * - * Implementation to be provided by the reverse iterator of the map - * managed by thr Cache_Map_manager. - */ -template -class ACE_Cache_Map_Reverse_Iterator -{ -public: - // = Traits. - /// The actual value mapped to the key in the cache. The - /// are used by the strategy and is transparent to the cache user. - typedef ACE_Reference_Pair value_type; - typedef std::pair CACHE_VALUE; - - // = Initialisation and termination methods. - - ACE_Cache_Map_Reverse_Iterator (const REVERSE_IMPLEMENTATION &iterator_impl); - - /// Copy constructor. - ACE_Cache_Map_Reverse_Iterator (const ACE_Cache_Map_Reverse_Iterator &rhs); - - ~ACE_Cache_Map_Reverse_Iterator (void); - - // = Iteration methods. - - /// Assignment operator. - ACE_Cache_Map_Reverse_Iterator &operator= - (const ACE_Cache_Map_Reverse_Iterator &rhs); - - /// Comparison operators. - bool operator== (const ACE_Cache_Map_Reverse_Iterator &rhs) const; - bool operator!= (const ACE_Cache_Map_Reverse_Iterator &rhs) const; - - /// Returns a reference to the internal element @c this is pointing - /// to. - ACE_Reference_Pair operator* (void) const; - - // = STL styled iteration, compare, and reference functions. - - /// Prefix advance - ACE_Cache_Map_Reverse_Iterator &operator++ (void); - - /// Postfix advance. - ACE_Cache_Map_Reverse_Iterator operator++ (int); - - /// Prefix reverse. - ACE_Cache_Map_Reverse_Iterator &operator-- (void); - - /// Postfix reverse. - ACE_Cache_Map_Reverse_Iterator operator-- (int); - - /// Returns the iterator of the internal map in the custody of the - /// Cache_Map_Manager. - REVERSE_IMPLEMENTATION &iterator_implementation (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// The actual iterator which iterates internally on the map - /// belonging to the Cache_Map_Manager. - REVERSE_IMPLEMENTATION reverse_iterator_implementation_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Cache_Map_Manager_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Cache_Map_Manager_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Cache_Map_Manager_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_CACHE_MAP_MANAGER_T_H */ diff --git a/deps/acelite/ace/Cache_Map_Manager_T.inl b/deps/acelite/ace/Cache_Map_Manager_T.inl deleted file mode 100644 index dc2a42ef0..000000000 --- a/deps/acelite/ace/Cache_Map_Manager_T.inl +++ /dev/null @@ -1,243 +0,0 @@ -// -*- C++ -*- -// -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE int -ACE_Cache_Map_Manager::purge (void) -{ - return this->caching_strategy ().caching_utility ().clear_cache (this->map_, - this->caching_strategy ().purge_percent ()); -} - -template ACE_INLINE size_t -ACE_Cache_Map_Manager::current_size (void) const -{ - return this->map_.current_size (); -} - -template ACE_INLINE size_t -ACE_Cache_Map_Manager::total_size (void) const -{ - return this->map_.total_size (); -} - -template ACE_INLINE CMAP_TYPE & -ACE_Cache_Map_Manager::map (void) -{ - return this->map_; -} - -template ACE_INLINE CACHING_STRATEGY & -ACE_Cache_Map_Manager::caching_strategy (void) -{ - return this->caching_strategy_; -} - -template ACE_INLINE ACE_Cache_Map_Iterator -ACE_Cache_Map_Manager::begin (void) -{ - return ITERATOR (this->map_.begin ()); -} - -template ACE_INLINE ACE_Cache_Map_Iterator -ACE_Cache_Map_Manager::end (void) -{ - return ITERATOR (this->map_.end ()); -} - -template ACE_INLINE ACE_Cache_Map_Reverse_Iterator -ACE_Cache_Map_Manager::rbegin (void) -{ - return REVERSE_ITERATOR (this->map_.rbegin ()); -} -template ACE_INLINE ACE_Cache_Map_Reverse_Iterator -ACE_Cache_Map_Manager::rend (void) -{ - return REVERSE_ITERATOR (this->map_.rend ()); -} - -//////////////////////////////////////////////////////////////////////////////// - -template ACE_INLINE -ACE_Cache_Map_Iterator::ACE_Cache_Map_Iterator (const ACE_Cache_Map_Iterator &rhs) - : iterator_implementation_ (rhs.iterator_implementation_) -{ -} - -template ACE_INLINE ACE_Cache_Map_Iterator & -ACE_Cache_Map_Iterator::operator= (const ACE_Cache_Map_Iterator &rhs) -{ - this->iterator_implementation_ = rhs.iterator_implementation_; - return *this; -} - -template ACE_INLINE bool -ACE_Cache_Map_Iterator::operator== (const ACE_Cache_Map_Iterator &rhs) const -{ - return this->iterator_implementation_ == rhs.iterator_implementation_; -} - -template ACE_INLINE bool -ACE_Cache_Map_Iterator::operator!= (const ACE_Cache_Map_Iterator &rhs) const -{ - return this->iterator_implementation_ != rhs.iterator_implementation_; -} - -template ACE_INLINE ACE_Reference_Pair -ACE_Cache_Map_Iterator::operator* (void) const -{ - value_type retn ((*this->iterator_implementation_).ext_id_, - (*this->iterator_implementation_).int_id_.first); - return retn; -} - -template ACE_INLINE -ACE_Cache_Map_Iterator & -ACE_Cache_Map_Iterator::operator++ (void) -{ - ++this->iterator_implementation_; - return *this; -} - -template ACE_INLINE -ACE_Cache_Map_Iterator -ACE_Cache_Map_Iterator::operator++ (int) -{ - ACE_Cache_Map_Iterator retn = *this; - ++this->iterator_implementation_; - return retn; -} - -template ACE_INLINE -ACE_Cache_Map_Iterator & -ACE_Cache_Map_Iterator::operator-- (void) -{ - --this->iterator_implementation_; - return *this; -} - -template ACE_INLINE -ACE_Cache_Map_Iterator -ACE_Cache_Map_Iterator::operator-- (int) -{ - ACE_Cache_Map_Iterator retn = *this; - --this->iterator_implementation_; - return retn; -} - -template ACE_INLINE void -ACE_Cache_Map_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - this->iterator_implementation_.dump (); -#endif /* ACE_HAS_DUMP */ -} - -template ACE_INLINE -ACE_Cache_Map_Iterator::ACE_Cache_Map_Iterator (const IMPLEMENTATION &iterator_impl) - : iterator_implementation_ (iterator_impl) -{ -} - -template ACE_INLINE IMPLEMENTATION & -ACE_Cache_Map_Iterator::iterator_implementation (void) -{ - return this->iterator_implementation_; -} - -//////////////////////////////////////////////////////////////////////////////// - -template ACE_INLINE -ACE_Cache_Map_Reverse_Iterator::ACE_Cache_Map_Reverse_Iterator (const ACE_Cache_Map_Reverse_Iterator &rhs) - : reverse_iterator_implementation_ (rhs.reverse_iterator_implementation_) -{ -} - -template ACE_INLINE -ACE_Cache_Map_Reverse_Iterator::~ACE_Cache_Map_Reverse_Iterator (void) -{ -} - -template ACE_INLINE ACE_Cache_Map_Reverse_Iterator & -ACE_Cache_Map_Reverse_Iterator::operator= (const ACE_Cache_Map_Reverse_Iterator &rhs) -{ - this->reverse_iterator_implementation_ = rhs.reverse_iterator_implementation_; - return *this; -} - -template ACE_INLINE bool -ACE_Cache_Map_Reverse_Iterator::operator== (const ACE_Cache_Map_Reverse_Iterator &rhs) const -{ - return this->reverse_iterator_implementation_ == rhs.reverse_iterator_implementation_; -} - -template ACE_INLINE bool -ACE_Cache_Map_Reverse_Iterator::operator!= (const ACE_Cache_Map_Reverse_Iterator &rhs) const -{ - return this->reverse_iterator_implementation_ != rhs.reverse_iterator_implementation_; -} - -template ACE_INLINE ACE_Reference_Pair -ACE_Cache_Map_Reverse_Iterator::operator* (void) const -{ - value_type retv ((*this->reverse_iterator_implementation_).ext_id_, - (*this->reverse_iterator_implementation_).int_id_.first); - return retv; -} - -template ACE_INLINE -ACE_Cache_Map_Reverse_Iterator & -ACE_Cache_Map_Reverse_Iterator::operator++ (void) -{ - ++this->reverse_iterator_implementation_; - return *this; -} - -template ACE_INLINE -ACE_Cache_Map_Reverse_Iterator -ACE_Cache_Map_Reverse_Iterator::operator++ (int) -{ - ACE_Cache_Map_Reverse_Iterator retn = *this; - ++this->reverse_iterator_implementation_; - return retn; -} - -template ACE_INLINE -ACE_Cache_Map_Reverse_Iterator & -ACE_Cache_Map_Reverse_Iterator::operator-- (void) -{ - --this->reverse_iterator_implementation_; - return *this; -} - -template ACE_INLINE -ACE_Cache_Map_Reverse_Iterator -ACE_Cache_Map_Reverse_Iterator::operator-- (int) -{ - ACE_Cache_Map_Reverse_Iterator retn = *this; - --this->reverse_iterator_implementation_; - return retn; -} - - -template ACE_INLINE void -ACE_Cache_Map_Reverse_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - this->reverse_iterator_implementation_.dump (); -#endif /* ACE_HAS_DUMP */ -} - -template ACE_INLINE -ACE_Cache_Map_Reverse_Iterator::ACE_Cache_Map_Reverse_Iterator (const REVERSE_IMPLEMENTATION &iterator_impl) - : reverse_iterator_implementation_(iterator_impl) -{ -} - -template ACE_INLINE REVERSE_IMPLEMENTATION & -ACE_Cache_Map_Reverse_Iterator::iterator_implementation (void) -{ - return this->reverse_iterator_implementation_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Cached_Connect_Strategy_T.cpp b/deps/acelite/ace/Cached_Connect_Strategy_T.cpp deleted file mode 100644 index 7987655b4..000000000 --- a/deps/acelite/ace/Cached_Connect_Strategy_T.cpp +++ /dev/null @@ -1,728 +0,0 @@ -#ifndef ACE_CACHED_CONNECT_STRATEGY_T_CPP -#define ACE_CACHED_CONNECT_STRATEGY_T_CPP - -#include "ace/Cached_Connect_Strategy_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/ACE.h" -#include "ace/Service_Repository.h" -#include "ace/Service_Types.h" -#include "ace/Thread_Manager.h" -#include "ace/WFMO_Reactor.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tcoccc (ACE_Cached_Connect_Strategy_Ex) -ACE_ALLOC_HOOK_DEFINE_Tcoccc (ACE_Bounded_Cached_Connect_Strategy) - -template -ACE_Cached_Connect_Strategy_Ex::ACE_Cached_Connect_Strategy_Ex -(CACHING_STRATEGY &caching_s, - ACE_Creation_Strategy *cre_s, - ACE_Concurrency_Strategy *con_s, - ACE_Recycling_Strategy *rec_s, - MUTEX *lock, - int delete_lock) - : CCSBASE (cre_s, con_s, rec_s, lock, delete_lock), - connection_cache_ (caching_s) -{ - if (this->open (cre_s, con_s, rec_s) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Cached_Connect_Strategy_Ex\n"))); -} - -template -ACE_Cached_Connect_Strategy_Ex::~ACE_Cached_Connect_Strategy_Ex (void) -{ - cleanup (); -} - - -template int -ACE_Cached_Connect_Strategy_Ex::check_hint_i -(SVC_HANDLER *&sh, - const ACE_PEER_CONNECTOR_ADDR &remote_addr, - ACE_Time_Value *timeout, - const ACE_PEER_CONNECTOR_ADDR &local_addr, - bool reuse_addr, - int flags, - int perms, - ACE_Hash_Map_Entry, std::pair > *&entry, - int &found) -{ - ACE_UNUSED_ARG (remote_addr); - ACE_UNUSED_ARG (timeout); - ACE_UNUSED_ARG (local_addr); - ACE_UNUSED_ARG (reuse_addr); - ACE_UNUSED_ARG (flags); - ACE_UNUSED_ARG (perms); - - found = 0; - - // Get the recycling act for the svc_handler - CONNECTION_CACHE_ENTRY *possible_entry = - (CONNECTION_CACHE_ENTRY *) sh->recycling_act (); - - // Check to see if the hint svc_handler has been closed down - if (possible_entry->ext_id_.recycle_state () == ACE_RECYCLABLE_CLOSED) - { - // If close, decrement refcount - if (possible_entry->ext_id_.decrement () == 0) - { - // If refcount goes to zero, close down the svc_handler - possible_entry->int_id_.first->recycler (0, 0); - possible_entry->int_id_.first->close (); - this->purge_i (possible_entry); - } - - // Hint not successful - found = 0; - - // Reset hint - sh = 0; - } - - // If hint is not closed, see if it is connected to the correct - // address and is recyclable - else if ((possible_entry->ext_id_.recycle_state () == ACE_RECYCLABLE_IDLE_AND_PURGABLE || - possible_entry->ext_id_.recycle_state () == ACE_RECYCLABLE_IDLE_BUT_NOT_PURGABLE) && - possible_entry->ext_id_.subject () == remote_addr) - { - // Hint successful - found = 1; - - // Tell the that it should prepare itself for - // being recycled. - this->prepare_for_recycling (sh); - - // - // Update the caching attributes directly since we don't do a - // find() on the cache map. - // - - // Indicates successful find. - int find_result = 0; - - int result = this->caching_strategy ().notify_find (find_result, - possible_entry->int_id_.second); - - if (result == -1) - return result; - } - else - { - // This hint will not be used. - possible_entry->ext_id_.decrement (); - - // Hint not successful - found = 0; - - // If is not connected to the correct address or is busy, - // we will not use it. - sh = 0; - } - - if (found) - entry = possible_entry; - - return 0; -} - -template int -ACE_Cached_Connect_Strategy_Ex::find_or_create_svc_handler_i -(SVC_HANDLER *&sh, - const ACE_PEER_CONNECTOR_ADDR &remote_addr, - ACE_Time_Value *timeout, - const ACE_PEER_CONNECTOR_ADDR &local_addr, - bool reuse_addr, - int flags, - int perms, - ACE_Hash_Map_Entry, std::pair > *&entry, - int &found) -{ - REFCOUNTED_HASH_RECYCLABLE_ADDRESS search_addr (remote_addr); - - // Try to find the address in the cache. Only if we don't find it - // do we create a new and connect it with the server. - while (this->find (search_addr, entry) != -1) - { - // We found a cached svc_handler. - // Get the cached - sh = entry->int_id_.first; - - // Is the connection clean? - int const state_result = - ACE::handle_ready (sh->peer ().get_handle (), - &ACE_Time_Value::zero, - true, // read ready - false, // write ready - true);// exception ready - - if (state_result == 1) - { - - if (sh->close () == -1) - return -1; - - sh = 0; - - // Cycle it once again.. - } - else if ((state_result == -1) && (errno == ETIME)) - { - // Found!!! - // Set the flag - found = 1; - - // Tell the that it should prepare itself for - // being recycled. - if (this->prepare_for_recycling (sh) == -1) - return -1; - - return 0; - } - else - { - return -1; - } - } - - // Not found... - - // Set the flag - found = 0; - - // We need to use a temporary variable here since we are not - // allowed to change because other threads may use this - // when we let go of the lock during the OS level connect. - // - // Note that making a new svc_handler, connecting remotely, - // binding to the map, and assigning of the hint and recycler - // should be atomic to the outside world. - SVC_HANDLER *potential_handler = 0; - - // Create a new svc_handler - if (this->make_svc_handler (potential_handler) == -1) - return -1; - - // Connect using the svc_handler. - if (this->cached_connect (potential_handler, - remote_addr, - timeout, - local_addr, - reuse_addr, - flags, - perms) == -1) - { - // Close the svc handler. - potential_handler->close (0); - - return -1; - } - else - { - // Insert the new SVC_HANDLER instance into the cache. - if (this->connection_cache_.bind (search_addr, - potential_handler, - entry) == -1) - { - // Close the svc handler and reset . - potential_handler->close (0); - - return -1; - } - - // Everything succeeded as planned. Assign to - // . - sh = potential_handler; - - // Set the recycler and the recycling act - - this->assign_recycler (sh, this, entry); - } - - return 0; -} - -template int -ACE_Cached_Connect_Strategy_Ex::cached_connect (SVC_HANDLER *&sh, - const ACE_PEER_CONNECTOR_ADDR &remote_addr, - ACE_Time_Value *timeout, - const ACE_PEER_CONNECTOR_ADDR &local_addr, - bool reuse_addr, - int flags, - int perms) -{ - // Actively establish the connection. This is a timed blocking - // connect. - if (this->new_connection (sh, - remote_addr, - timeout, - local_addr, - reuse_addr, - flags, - perms) == -1) - { - // If connect() failed because of timeouts, we have to reject - // the connection entirely. This is necessary since currently - // there is no way for the non-blocking connects to complete and - // for the to notify the cache of the completion of - // connect(). - - if (errno == EWOULDBLOCK || errno == ETIMEDOUT) - errno = ENOTSUP; - else if (ACE::out_of_handles (errno) || errno == EADDRINUSE) - { - // If the connect failed due to the process running out of - // file descriptors then, auto_purging of some connections - // are done from the CONNECTION_CACHE. This frees the - // descriptors which get used in the connect process and - // hence the same method is called again! - if (this->purge_connections () == -1) - return -1; - - // Try connecting again. - if (this->new_connection (sh, - remote_addr, - timeout, - local_addr, - reuse_addr, - flags, - perms) == -1) - { - if (errno == EWOULDBLOCK || errno == ETIMEDOUT) - errno = ENOTSUP; - return -1; - } - } - else - { - return -1; - } - } - - return 0; - -} - - -template int -ACE_Cached_Connect_Strategy_Ex::connect_svc_handler_i -(SVC_HANDLER *&sh, - const ACE_PEER_CONNECTOR_ADDR &remote_addr, - ACE_Time_Value *timeout, - const ACE_PEER_CONNECTOR_ADDR &local_addr, - bool reuse_addr, - int flags, - int perms, - int& found) -{ - CONNECTION_CACHE_ENTRY *entry = 0; - - // Check if the user passed a hint svc_handler - if (sh != 0) - { - int result = this->check_hint_i (sh, - remote_addr, - timeout, - local_addr, - reuse_addr, - flags, - perms, - entry, - found); - if (result != 0) - return result; - } - - // If not found - if (!found) - { - int result = this->find_or_create_svc_handler_i (sh, - remote_addr, - timeout, - local_addr, - reuse_addr, - flags, - perms, - entry, - found); - - if (result != 0) - return result; - - // Increment the refcount - entry->ext_id_.increment (); - } - - if (entry) - { - // For all successful cases: mark the in the cache - // as being . Therefore recyclable is BUSY. - entry->ext_id_.recycle_state (ACE_RECYCLABLE_BUSY); - } - - return 0; -} - - -template int -ACE_Cached_Connect_Strategy_Ex::cache_i (const void *recycling_act) -{ - // The wonders and perils of ACT - CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) recycling_act; - - // Mark the in the cache as not being . - // Therefore recyclable is IDLE. - entry->ext_id_.recycle_state (ACE_RECYCLABLE_IDLE_AND_PURGABLE); - - return 0; -} - -template int -ACE_Cached_Connect_Strategy_Ex::recycle_state_i (const void *recycling_act, - ACE_Recyclable_State new_state) -{ - // The wonders and perils of ACT - CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) recycling_act; - - // Mark the in the cache as not being . - // Therefore recyclable is IDLE. - entry->ext_id_.recycle_state (new_state); - - return 0; -} - -template ACE_Recyclable_State -ACE_Cached_Connect_Strategy_Ex::recycle_state_i (const void *recycling_act) const -{ - // The wonders and perils of ACT - CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) recycling_act; - - // Mark the in the cache as not being . - // Therefore recyclable is IDLE. - return entry->ext_id_.recycle_state (); -} - -template int -ACE_Cached_Connect_Strategy_Ex::purge_i (const void *recycling_act) -{ - // The wonders and perils of ACT - CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) recycling_act; - - return this->connection_cache_.unbind (entry); -} - - -template int -ACE_Cached_Connect_Strategy_Ex::mark_as_closed_i (const void *recycling_act) -{ - // The wonders and perils of ACT - CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) recycling_act; - - // Mark the in the cache as CLOSED. - entry->ext_id_.recycle_state (ACE_RECYCLABLE_CLOSED); - - return 0; -} - -template int -ACE_Cached_Connect_Strategy_Ex::cleanup_hint_i (const void *recycling_act, - void **act_holder) -{ - // Reset the <*act_holder> in the confines and protection of the - // lock. - if (act_holder) - *act_holder = 0; - - // The wonders and perils of ACT - CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) recycling_act; - - // Decrement the refcount on the . - int refcount = entry->ext_id_.decrement (); - - // If the svc_handler state is closed and the refcount == 0, call - // close() on svc_handler. - if (entry->ext_id_.recycle_state () == ACE_RECYCLABLE_CLOSED && - refcount == 0) - { - entry->int_id_.first->recycler (0, 0); - entry->int_id_.first->close (); - this->purge_i (entry); - } - - return 0; -} - -template int -ACE_Cached_Connect_Strategy_Ex::purge_connections (void) -{ - return this->connection_cache_.purge (); -} - -template CACHING_STRATEGY & -ACE_Cached_Connect_Strategy_Ex::caching_strategy (void) -{ - return this->connection_cache_.caching_strategy (); -} - -template int -ACE_Cached_Connect_Strategy_Ex::find (ACE_Refcounted_Hash_Recyclable &search_addr, - ACE_Hash_Map_Entry, std::pair > *&entry) -{ - typedef ACE_Hash_Map_Bucket_Iterator, - ACE_Hash, - ACE_Equal_To, - ACE_Null_Mutex> - CONNECTION_CACHE_BUCKET_ITERATOR; - - CONNECTION_CACHE_BUCKET_ITERATOR iterator (this->connection_cache_.map (), - search_addr); - - CONNECTION_CACHE_BUCKET_ITERATOR end (this->connection_cache_.map (), - search_addr, - 1); - - for (; - iterator != end; - ++iterator) - { - REFCOUNTED_HASH_RECYCLABLE_ADDRESS &addr = (*iterator).ext_id_; - - if (addr.recycle_state () != ACE_RECYCLABLE_IDLE_AND_PURGABLE && - addr.recycle_state () != ACE_RECYCLABLE_IDLE_BUT_NOT_PURGABLE) - continue; - - if (addr.subject () != search_addr.subject ()) - continue; - - entry = &(*iterator); - - // - // Update the caching attributes directly since we don't do a - // find() on the cache map. - // - - // Indicates successful find. - int find_result = 0; - - int result = this->caching_strategy ().notify_find (find_result, - entry->int_id_.second); - - if (result == -1) - return result; - - return 0; - } - - return -1; -} - -template void -ACE_Cached_Connect_Strategy_Ex::cleanup (void) -{ - // Excluded other threads from changing the cache while we cleanup - ACE_GUARD (MUTEX, ace_mon, *this->lock_); - - // Close down all cached service handlers. - typename CONNECTION_CACHE::ITERATOR iter = this->connection_cache_.begin (); - while (iter != this->connection_cache_.end ()) - { - if ((*iter).second () != 0) - { - // save entry for future use - CONNECTION_CACHE_ENTRY *entry = (CONNECTION_CACHE_ENTRY *) - (*iter).second ()->recycling_act (); - - // close handler - (*iter).second ()->recycler (0, 0); - (*iter).second ()->close (); - - // remember next iter - typename CONNECTION_CACHE::ITERATOR next_iter = iter; - ++next_iter; - - // purge the item from the hash - this->purge_i (entry); - - // assign next iter - iter = next_iter; - } - else - ++iter; - } -} - -///////////////////////////////////////////////////////////////////////// - -template -ACE_Bounded_Cached_Connect_Strategy::ACE_Bounded_Cached_Connect_Strategy -(size_t max_size, - CACHING_STRATEGY &caching_s, - ACE_Creation_Strategy *cre_s, - ACE_Concurrency_Strategy *con_s, - ACE_Recycling_Strategy *rec_s, - MUTEX *lock, - int delete_lock) - : CCSEBASE (caching_s, cre_s, con_s, rec_s, lock, delete_lock), - max_size_ (max_size) -{ -} - -template -ACE_Bounded_Cached_Connect_Strategy::~ACE_Bounded_Cached_Connect_Strategy(void) -{ -} - -template -int -ACE_Bounded_Cached_Connect_Strategy::find_or_create_svc_handler_i -(SVC_HANDLER *&sh, - const ACE_PEER_CONNECTOR_ADDR &remote_addr, - ACE_Time_Value *timeout, - const ACE_PEER_CONNECTOR_ADDR &local_addr, - bool reuse_addr, - int flags, - int perms, - ACE_Hash_Map_Entry, - std::pair > *&entry, - int &found) -{ - - REFCOUNTED_HASH_RECYCLABLE_ADDRESS search_addr (remote_addr); - - // Try to find the address in the cache. Only if we don't find it - // do we create a new and connect it with the server. - while (this->find (search_addr, entry) != -1) - { - // We found a cached svc_handler. - // Get the cached - sh = entry->int_id_.first (); - - // Is the connection clean? - int state_result= ACE::handle_ready (sh->peer ().get_handle (), - &ACE_Time_Value::zero, - true, // read ready - false, // write ready - true);// exception ready - - if (state_result == 1) - { - // The connection was disconnected during idle. - // close the svc_handler down. - if (sh->close () == -1) - { - ACE_ASSERT (0); - return -1; - } - sh = 0; - // and rotate once more... - } - else if ((state_result == -1) && (errno == ETIME)) - { - // Found!!! - // Set the flag - found = 1; - - // Tell the that it should prepare itself for - // being recycled. - if (this->prepare_for_recycling (sh) == -1) - { - ACE_ASSERT (0); - return -1; - } - - return 0; - } - else // some other return value or error... - { - ACE_ASSERT (0); // just to see it coming - - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("(%t)ACE_Bounded_Cached_Connect_Strategy<>::") - ACE_TEXT ("find_or_create_svc_handler_i - ") - ACE_TEXT ("error polling server socket state.\n"))); - - return -1; - } - } - - // Not found... - - // Set the flag - found = 0; - - // Check the limit of handlers... - if ((this->max_size_ > 0) && - (this->connection_cache_.current_size () >= this->max_size_)) - { - // Try to purge idle connections - if (this->purge_connections () == -1) - return -1; - - // Check limit again. - if (this->connection_cache_.current_size () >= this->max_size_) - // still too much! - return -1; - - // OK, we have room now... - } - - // We need to use a temporary variable here since we are not - // allowed to change because other threads may use this - // when we let go of the lock during the OS level connect. - // - // Note that making a new svc_handler, connecting remotely, - // binding to the map, and assigning of the hint and recycler - // should be atomic to the outside world. - SVC_HANDLER *potential_handler = 0; - - // Create a new svc_handler - if (this->make_svc_handler (potential_handler) == -1) - return -1; - - // Connect using the svc_handler. - if (this->cached_connect (potential_handler, - remote_addr, - timeout, - local_addr, - reuse_addr, - flags, - perms) == -1) - { - // Close the svc handler. - potential_handler->close (0); - return -1; - } - else - { - // Insert the new SVC_HANDLER instance into the cache. - if (this->connection_cache_.bind (search_addr, - potential_handler, - entry) == -1) - { - // Close the svc handler and reset . - potential_handler->close (0); - - return -1; - } - - // Everything succeeded as planned. Assign to - // . - sh = potential_handler; - - // Set the recycler and the recycling act - this->assign_recycler (sh, this, entry); - } - - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_CACHED_CONNECT_STRATEGY_T_CPP */ diff --git a/deps/acelite/ace/Cached_Connect_Strategy_T.h b/deps/acelite/ace/Cached_Connect_Strategy_T.h deleted file mode 100644 index 1ab9fe8e5..000000000 --- a/deps/acelite/ace/Cached_Connect_Strategy_T.h +++ /dev/null @@ -1,259 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Cached_Connect_Strategy_T.h - * - * @author Kirthika Parameswaran - */ -//============================================================================= - -#ifndef CACHED_CONNECT_STRATEGY_T_H -#define CACHED_CONNECT_STRATEGY_T_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Strategies_T.h" -#include "ace/Hash_Cache_Map_Manager_T.h" -#include "ace/Caching_Strategies_T.h" -#include "ace/Functor_T.h" -#include "ace/Pair_T.h" - -// For linkers which cant grok long names... -#define ACE_Cached_Connect_Strategy_Ex ACCSE - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Cached_Connect_Strategy_Ex - * - * @brief A connection strategy which caches connections to peers - * (represented by SVC_HANDLER instances), thereby allowing - * subsequent re-use of unused, but available, connections. - * - * is intended to be used as a - * plug-in connection strategy for ACE_Strategy_Connector. - * It's added value is re-use of established connections and - * tweaking the role of the cache as per the caching strategy. - */ -template -class ACE_Cached_Connect_Strategy_Ex - : public ACE_Cached_Connect_Strategy -{ -public: - /// Constructor - ACE_Cached_Connect_Strategy_Ex ( - CACHING_STRATEGY &caching_s, - ACE_Creation_Strategy *cre_s = 0, - ACE_Concurrency_Strategy *con_s = 0, - ACE_Recycling_Strategy *rec_s = 0, - MUTEX *lock = 0, - int delete_lock = 0); - - /// Destructor - virtual ~ACE_Cached_Connect_Strategy_Ex (void); - - /// Explicit purging of connection entries from the connection cache. - virtual int purge_connections (void); - - /// Mark as closed (non-locking version). This is used during the cleanup of the - /// connections purged. - virtual int mark_as_closed_i (const void *recycling_act); - - /** - * Since g++ version < 2.8 arent happy with templates, this special - * method had to be devised to avoid memory leaks and perform - * cleanup of the . - */ - void cleanup (void); - - // = Typedefs for managing the map - typedef ACE_Refcounted_Hash_Recyclable - REFCOUNTED_HASH_RECYCLABLE_ADDRESS; - typedef ACE_Hash_Cache_Map_Manager, - ACE_Equal_To, - CACHING_STRATEGY, - ATTRIBUTES> - CONNECTION_CACHE; - typedef typename CONNECTION_CACHE::CACHE_ENTRY CONNECTION_CACHE_ENTRY; - typedef typename CONNECTION_CACHE::key_type KEY; - typedef typename CONNECTION_CACHE::mapped_type VALUE; - - typedef ACE_Recyclable_Handler_Cleanup_Strategy, - ACE_Hash_Map_Manager_Ex, - ACE_Hash, - ACE_Equal_To, - MUTEX> > - CLEANUP_STRATEGY; - - typedef ACE_Cached_Connect_Strategy - CCSBASE; - - // = Accessor. - CACHING_STRATEGY &caching_strategy (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Find an idle handle. - int find (ACE_Refcounted_Hash_Recyclable &search_addr, - ACE_Hash_Map_Entry, std::pair > *&entry); - - /// Remove from cache (non-locking version). - virtual int purge_i (const void *recycling_act); - - /// Add to cache (non-locking version). - virtual int cache_i (const void *recycling_act); - - /// Get/Set recycle_state (non-locking version). - virtual int recycle_state_i (const void *recycling_act, - ACE_Recyclable_State new_state); - virtual ACE_Recyclable_State recycle_state_i (const void *recycling_act) const; - - /// Cleanup hint and reset @c *act_holder to zero if @a act_holder != 0. - virtual int cleanup_hint_i (const void *recycling_act, - void **act_holder); - - // = Helpers - int check_hint_i (SVC_HANDLER *&sh, - const ACE_PEER_CONNECTOR_ADDR &remote_addr, - ACE_Time_Value *timeout, - const ACE_PEER_CONNECTOR_ADDR &local_addr, - bool reuse_addr, - int flags, - int perms, - ACE_Hash_Map_Entry, std::pair > *&entry, - int &found); - - virtual int find_or_create_svc_handler_i (SVC_HANDLER *&sh, - const ACE_PEER_CONNECTOR_ADDR &remote_addr, - ACE_Time_Value *timeout, - const ACE_PEER_CONNECTOR_ADDR &local_addr, - bool reuse_addr, - int flags, - int perms, - ACE_Hash_Map_Entry, std::pair > *&entry, - int &found); - - virtual int connect_svc_handler_i (SVC_HANDLER *&sh, - const ACE_PEER_CONNECTOR_ADDR &remote_addr, - ACE_Time_Value *timeout, - const ACE_PEER_CONNECTOR_ADDR &local_addr, - bool reuse_addr, - int flags, - int perms, - int &found); - - /** - * Connection of the svc_handler with the remote host. This method - * also encapsulates the connection done with auto_purging under the - * hood. If the connect failed due to the process running out of - * file descriptors then, auto_purging of some connections are done - * from the CONNECTION_CACHE. This frees the descriptors which get - * used in the connect process and hence the connect operation can - * succeed. - */ - virtual int cached_connect (SVC_HANDLER *&sh, - const ACE_PEER_CONNECTOR_ADDR &remote_addr, - ACE_Time_Value *timeout, - const ACE_PEER_CONNECTOR_ADDR &local_addr, - bool reuse_addr, - int flags, - int perms); - - /// Table that maintains the cache of connected SVC_HANDLERs. - CONNECTION_CACHE connection_cache_; -}; - -///////////////////////////////////////////////////////////////////////////// - -// For linkers which cant grok long names... -#define ACE_Bounded_Cached_Connect_Strategy ABCCS - -/** - * @class ACE_Bounded_Cached_Connect_Strategy - * - * @brief - * A connection strategy which caches connections to peers - * (represented by SVC_HANDLER instances), thereby allowing - * subsequent re-use of unused, but available, connections. - * This strategy should be used when the cache is bounded by - * maximum size. - * - * Bounded_Cached_Connect_Strategy is intended to be used as a - * plug-in connection strategy for ACE_Strategy_Connector. - * It's added value is re-use of established connections and - * tweaking the role of the cache as per the caching strategy. - * Thanks to Edan Ayal for contributing this - * class and Susan Liebeskind for - * brainstorming about it. - */ -template -class ACE_Bounded_Cached_Connect_Strategy - : public ACE_Cached_Connect_Strategy_Ex -{ - typedef ACE_Cached_Connect_Strategy_Ex - CCSEBASE; - - // = Typedefs for managing the map - typedef ACE_Refcounted_Hash_Recyclable - REFCOUNTED_HASH_RECYCLABLE_ADDRESS; - -public: - /// Constructor - ACE_Bounded_Cached_Connect_Strategy (size_t max_size, - CACHING_STRATEGY &caching_s, - ACE_Creation_Strategy *cre_s = 0, - ACE_Concurrency_Strategy *con_s = 0, - ACE_Recycling_Strategy *rec_s = 0, - MUTEX *lock = 0, - int delete_lock = 0); - - /// Destructor - virtual ~ACE_Bounded_Cached_Connect_Strategy (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - virtual int find_or_create_svc_handler_i (SVC_HANDLER *&sh, - const ACE_PEER_CONNECTOR_ADDR &remote_addr, - ACE_Time_Value *timeout, - const ACE_PEER_CONNECTOR_ADDR &local_addr, - bool reuse_addr, - int flags, - int perms, - ACE_Hash_Map_Entry, - std::pair > *&entry, - int &found); - -protected: - /// Max items in the cache, used as a bound for the creation of svc_handlers. - size_t max_size_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Cached_Connect_Strategy_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Cached_Connect_Strategy_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* CACHED_CONNECT_STRATEGY_T_H */ diff --git a/deps/acelite/ace/Caching_Strategies_T.cpp b/deps/acelite/ace/Caching_Strategies_T.cpp deleted file mode 100644 index 0cc25407a..000000000 --- a/deps/acelite/ace/Caching_Strategies_T.cpp +++ /dev/null @@ -1,58 +0,0 @@ -#ifndef ACE_CACHING_STRATEGIES_T_CPP -#define ACE_CACHING_STRATEGIES_T_CPP - -#include "ace/Caching_Strategies_T.h" -#include "ace/Log_Category.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Caching_Strategies_T.inl" -#endif /* __ACE_INLINE__ */ - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Caching_Strategy::~ACE_Caching_Strategy (void) -{ -} - -////////////////////////////////////////////////////////////////////////////////// - -template -ACE_LRU_Caching_Strategy::ACE_LRU_Caching_Strategy (void) - : timer_ (0), - purge_percent_ (10) -{ -} - -//////////////////////////////////////////////////////////////////////////////////////////////// - -template -ACE_LFU_Caching_Strategy::ACE_LFU_Caching_Strategy (void) - : purge_percent_ (10) -{ -} - -//////////////////////////////////////////////////////////////////////////////////////////////// - -template -ACE_FIFO_Caching_Strategy::ACE_FIFO_Caching_Strategy (void) - : order_ (0), - purge_percent_ (10) -{ -} - -//////////////////////////////////////////////////////////////////////////////////////////////// - -ACE_ALLOC_HOOK_DEFINE_Tccc(ACE_Caching_Strategy_Adapter) -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_LRU_Caching_Strategy) -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_LFU_Caching_Strategy) -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_FIFO_Caching_Strategy) -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Null_Caching_Strategy) - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_CACHING_STRATEGIES_T_CPP */ diff --git a/deps/acelite/ace/Caching_Strategies_T.h b/deps/acelite/ace/Caching_Strategies_T.h deleted file mode 100644 index 243d10c6a..000000000 --- a/deps/acelite/ace/Caching_Strategies_T.h +++ /dev/null @@ -1,551 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Caching_Strategies_T.h - * - * @author Kirthika Parameswaran - */ -//============================================================================= - -#ifndef ACE_CACHING_STRATEGIES_H -#define ACE_CACHING_STRATEGIES_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" -#include "ace/Caching_Utility_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined(_MSC_VER) -#pragma warning(disable:4503) -#endif /* _MSC_VER */ - -// For linkers that cant grok long names. -#define ACE_Caching_Strategy ACS - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Caching_Strategy - * - * @brief This class is an abstract base class for a caching strategy. - * - * This class consists of all the interfaces a caching strategy should - * have and is used in association with the - * ACE_Caching_Strategy_Adaptor. - */ -template -class ACE_Caching_Strategy -{ -public: - /// Destructor. - virtual ~ACE_Caching_Strategy (void); - - /// Accessor method for the timer attributes. - virtual ATTRIBUTES attributes (void) = 0; - - /// Get the percentage of entries to purge. - virtual double purge_percent (void) = 0; - - /// Set the percentage of entries to purge. - virtual void purge_percent (double percentage) = 0; - - // = Strategy related Operations - - /// This method acts as a notification about the CONTAINERs bind - /// method call. - virtual int notify_bind (int result, - const ATTRIBUTES &attr) = 0; - - /// This method acts as a notification about the CONTAINERs find - /// method call - virtual int notify_find (int result, - ATTRIBUTES &attr) = 0; - - /// This method acts as a notification about the CONTAINERs unbind - /// method call - virtual int notify_unbind (int result, - const ATTRIBUTES &attr) = 0; - - /// This method acts as a notification about the CONTAINERs trybind - /// method call - virtual int notify_trybind (int result, - ATTRIBUTES &attr) = 0; - - /// This method acts as a notification about the CONTAINERs rebind - /// method call - virtual int notify_rebind (int result, - const ATTRIBUTES &attr) = 0; - - /// Purge the cache. - virtual CACHING_UTILITY &caching_utility (void) = 0; - - /// Dumps the state of the object. - virtual void dump (void) const = 0; -}; - -////////////////////////////////////////////////////////////////////////// - -#define ACE_Caching_Strategy_Adapter ACSA - -/** - * @class ACE_Caching_Strategy_Adapter - * - * @brief This class follows the Adaptor pattern and is used to provide - * External Polymorphism by deriving from ACE_Caching_Strategy. - * - * This class simply delegates all requests to the - * IMPLEMNETATION object within. This class should be passed in - * place of the the abstract base ACE_Caching_Strategy class as - * part of the External Polymorphism pattern. - */ -template -class ACE_Caching_Strategy_Adapter - : public ACE_Caching_Strategy -{ -public: - /// Constructor. - ACE_Caching_Strategy_Adapter (IMPLEMENTATION *implementation = 0, - bool delete_implementation = false); - - /// Destructor. - ~ACE_Caching_Strategy_Adapter (void); - - /// Accessor method for the timer attributes. - ATTRIBUTES attributes (void); - - /// Get the percentage of entries to purge. - double purge_percent (void); - - /// Set the percentage of entries to purge. - void purge_percent (double percentage); - - // = Strategy related Operations - - /// This method acts as a notification about the CONTAINERs bind - /// method call. - int notify_bind (int result, - const ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs find - /// method call - int notify_find (int result, - ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs unbind - /// method call - int notify_unbind (int result, - const ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs trybind - /// method call - int notify_trybind (int result, - ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs rebind - /// method call - int notify_rebind (int result, - const ATTRIBUTES &attr); - - /// Accessor to the implementation. - IMPLEMENTATION &implementation (void); - - /// Purge the cache. - CACHING_UTILITY &caching_utility (void); - - /// Dumps the state of the object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Implementation class. - IMPLEMENTATION *implementation_; - - /// Do we need to delete the implementation? - bool delete_implementation_; -}; - -////////////////////////////////////////////////////////////////////////// -#define ACE_LRU_Caching_Strategy ALRU - -/** - * @class ACE_LRU_Caching_Strategy - * - * @brief Defines a Least Recently Used strategy which will decide on - * the item to be removed from the cache. - * - * This is a strategy which makes use of a virtual timer which - * is updated whenever an item is inserted or looked up in the - * container. When the need of purging entries arises, the items - * with the lowest timer values are removed. - * Explanation of the template parameter list: - * CONTAINER is any map with entries of type . - * The ATTRIBUTES are the deciding factor for purging of entries - * and should logically be included with the VALUE. Some ways of - * doing this are: As being a member of the VALUE or VALUE being - * std::pair. The CACHING_UTILITY is the - * class which can be plugged in and which decides the entries - * to purge. - */ -template -class ACE_LRU_Caching_Strategy -{ -public: - // Traits. - typedef ATTRIBUTES CACHING_ATTRIBUTES; - - // = Initialisation and termination. - - /** - * The is the map in which the entries reside. The - * timer attribute is initialed to zero in this constructor. And - * the field denotes the percentage of the entries - * in the cache which can be purged automagically and by default is - * set to 10%. - */ - ACE_LRU_Caching_Strategy (void); - - // = Operations of the strategy. - - /// Accessor method for the timer attributes. - ATTRIBUTES attributes (void); - - /// Get the percentage of entries to purge. - double purge_percent (void); - - /// Set the percentage of entries to purge. - void purge_percent (double percentage); - - // = Strategy related Operations - - /// This method acts as a notification about the CONTAINERs bind - /// method call. - int notify_bind (int result, - const ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs find - /// method call - int notify_find (int result, - ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs unbind - /// method call - int notify_unbind (int result, - const ATTRIBUTES &attr); - - - /// This method acts as a notification about the CONTAINERs trybind - /// method call - int notify_trybind (int result, - ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs rebind - /// method call - int notify_rebind (int result, - const ATTRIBUTES &attr); - - /// Purge the cache. - CACHING_UTILITY &caching_utility (void); - - /// Dumps the state of the object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// This element is the one which is the deciding factor for purging - /// of an ITEM. - ATTRIBUTES timer_; - - /// The level about which the purging will happen automagically. - double purge_percent_; - - /// This is the helper class which will decide and expunge entries - /// from the cache. - CACHING_UTILITY caching_utility_; -}; - -////////////////////////////////////////////////////////////////////////// -#define ACE_LFU_Caching_Strategy ALFU - -/** - * @class ACE_LFU_Caching_Strategy - * - * @brief Defines a Least Frequently Used strategy for which will decide on - * the item to be removed from the cache. - * - * A attribute is tagged to each item which increments whenever - * the item is bound or looked up in the cache. Thus it denotes - * the frequency of use. According to the value of the attribute - * the item is removed from the CONTAINER i.e cache. - * Explanation of the template parameter list: - * CONTAINER is any map with entries of type . - * The ATTRIBUTES are the deciding factor for purging of entries - * and should logically be included with the VALUE. Some ways of - * doing this are: As being a member of the VALUE or VALUE being - * std::pair. The CACHING_UTILITY is the - * class which can be plugged in and which decides the entries - * to purge. - */ -template -class ACE_LFU_Caching_Strategy -{ -public: - // Traits. - typedef ATTRIBUTES CACHING_ATTRIBUTES; - - // = Initialisation and termination methods. - - /** - * The is the map in which the entries reside. The - * timer attribute is initialed to zero in this constructor. And - * the field denotes the percentage of the entries - * in the cache which can be purged automagically and by default is - * set to 10%. - */ - ACE_LFU_Caching_Strategy (void); - - // = Strategy methods. - - /// Access the attributes. - ATTRIBUTES attributes (void); - - /// Get the percentage of entries to purge. - double purge_percent (void); - - /// Set the percentage of entries to purge. - void purge_percent (double percentage); - - // = Strategy related Operations - - /// This method acts as a notification about the CONTAINERs bind - /// method call. - int notify_bind (int result, - const ATTRIBUTES &attr); - - /// Lookup notification. - int notify_find (int result, - ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs unbind - /// method call - int notify_unbind (int result, - const ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs trybind - /// method call - int notify_trybind (int result, - ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs rebind - /// method call - int notify_rebind (int result, - const ATTRIBUTES &attr); - - /// Purge the cache. - CACHING_UTILITY &caching_utility (void); - - /// Dumps the state of the object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// The level about which the purging will happen automagically. - double purge_percent_; - - /// This is the helper class which will decide and expunge entries - /// from the cache. - CACHING_UTILITY caching_utility_; -}; - -///////////////////////////////////////////////////////////// -#define ACE_FIFO_Caching_Strategy AFIFO - -/** - * @class ACE_FIFO_Caching_Strategy - * - * @brief The First In First Out strategy is implemented wherein each - * item is ordered. - * - * The order tag of each item is used to decide the item to be - * removed from the cache. The items with least order are removed. - * Explanation of the template parameter list: - * CONTAINER is any map with entries of type . - * The ATTRIBUTES are the deciding factor for purging of entries - * and should logically be included with the VALUE. Some ways of - * doing this are: As being a member of the VALUE or VALUE being - * std::pair. The CACHING_UTILITY is the - * class which can be plugged in and which decides the entries - * to purge. - */ -template -class ACE_FIFO_Caching_Strategy -{ -public: - typedef ATTRIBUTES CACHING_ATTRIBUTES; - - // = Initialisation and termination. - - /** - * The is the map in which the entries reside. The - * timer attribute is initialed to zero in this constructor. And - * the field denotes the percentage of the entries - * in the cache which can be purged automagically and by default is - * set to 10%. - */ - ACE_FIFO_Caching_Strategy (void); - - // = Strategy methods. - - /// Accessor method. - ATTRIBUTES attributes (void); - - /// Get the percentage of entries to purge. - double purge_percent (void); - - /// Set the percentage of entries to purge. - void purge_percent (double percentage); - - // = Strategy related Operations - - /// Notification for an item getting bound into the cache. - int notify_bind (int result, - const ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs find - /// method call - int notify_find (int result, - ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs unbind - /// method call - int notify_unbind (int result, - const ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs trybind - /// method call - int notify_trybind (int result, - ATTRIBUTES &attr); - - /// Notification for an item getting bound again into the cache. - int notify_rebind (int result, - const ATTRIBUTES &attr); - - /// Purge the cache. - CACHING_UTILITY &caching_utility (void); - - /// Dumps the state of the object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// The order is the deciding factor for the item to be removed from - /// the cache. - ATTRIBUTES order_; - - /// The level about which the purging will happen automagically. - double purge_percent_; - - /// This is the helper class which will decide and expunge entries - /// from the cache. - CACHING_UTILITY caching_utility_; -}; - -////////////////////////////////////////////////////////////////////// -#define ACE_Null_Caching_Strategy ANULL - -/** - * @class ACE_Null_Caching_Strategy - * - * @brief The is a special caching strategy which doesnt have the purging - * feature. - * - * No purging provided. To be used when purging might be too expensive - * an operation. - */ -template -class ACE_Null_Caching_Strategy -{ -public: - // = Traits. - typedef ATTRIBUTES CACHING_ATTRIBUTES; - - // = Strategy methods. All are NO_OP methods!!! - - /// Accessor method. - ATTRIBUTES attributes (void); - - /// Get the percentage of entries to purge. - double purge_percent (void); - - /// Set the percentage of entries to purge. - void purge_percent (double percentage); - - // = Strategy related Operations - - /// Notification for an item getting bound into the cache. - int notify_bind (int result, - const ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs find - /// method call - int notify_find (int result, - ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs unbind - /// method call - int notify_unbind (int result, - const ATTRIBUTES &attr); - - /// This method acts as a notification about the CONTAINERs trybind - /// method call - int notify_trybind (int result, - ATTRIBUTES &attr); - - /// Notification for an item getting bound again into the cache. - int notify_rebind (int result, - const ATTRIBUTES &attr); - - /// Purge the cache. - CACHING_UTILITY &caching_utility (void); - - /// Dumps the state of the object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// This is the helper class which will decide and expunge entries - /// from the cache. - CACHING_UTILITY caching_utility_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Caching_Strategies_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Caching_Strategies_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Caching_Strategies_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_CACHING_STRATEGIES_H */ diff --git a/deps/acelite/ace/Caching_Strategies_T.inl b/deps/acelite/ace/Caching_Strategies_T.inl deleted file mode 100644 index dd9c98513..000000000 --- a/deps/acelite/ace/Caching_Strategies_T.inl +++ /dev/null @@ -1,454 +0,0 @@ -// -*-C++-*- -// -////////////////////////////////////////////////////////////////////////////////// - -#include "ace/OS_Memory.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE -ACE_Caching_Strategy_Adapter::ACE_Caching_Strategy_Adapter (IMPLEMENTATION *implementation, - bool delete_implementation) - : implementation_ (implementation), - delete_implementation_ (delete_implementation) -{ - if (this->implementation_ == 0) - { - ACE_NEW (this->implementation_, - IMPLEMENTATION); - this->delete_implementation_ = true; - } -} - -template ACE_INLINE -ACE_Caching_Strategy_Adapter::~ACE_Caching_Strategy_Adapter (void) -{ - if (this->delete_implementation_) - { - delete this->implementation_; - this->delete_implementation_ = false; - this->implementation_ = 0; - } -} - -template ACE_INLINE ATTRIBUTES -ACE_Caching_Strategy_Adapter::attributes (void) -{ - return this->implementation_->attributes (); -} - -template ACE_INLINE double -ACE_Caching_Strategy_Adapter::purge_percent (void) -{ - return this->implementation_->purge_percent (); -} - -template ACE_INLINE void -ACE_Caching_Strategy_Adapter::purge_percent (double percentage) -{ - this->implementation_->purge_percent (percentage); -} - -template ACE_INLINE int -ACE_Caching_Strategy_Adapter::notify_bind (int result, - const ATTRIBUTES &attr) -{ - return this->implementation_->notify_bind (result, - attr); -} - -template ACE_INLINE int -ACE_Caching_Strategy_Adapter::notify_find (int result, - ATTRIBUTES &attr) -{ - return this->implementation_->notify_find (result, - attr); -} - -template ACE_INLINE int -ACE_Caching_Strategy_Adapter::notify_unbind (int result, - const ATTRIBUTES &attr) -{ - return this->implementation_->notify_unbind (result, - attr); -} - -template ACE_INLINE int -ACE_Caching_Strategy_Adapter::notify_trybind (int result, - ATTRIBUTES &attr) -{ - return this->implementation_->notify_trybind (result, - attr); -} - -template ACE_INLINE int -ACE_Caching_Strategy_Adapter::notify_rebind (int result, - const ATTRIBUTES &attr) -{ - return this->implementation_->notify_rebind (result, - attr); -} - -template ACE_INLINE IMPLEMENTATION & -ACE_Caching_Strategy_Adapter::implementation (void) -{ - return *this->implementation_; -} - -template ACE_INLINE CACHING_UTILITY & -ACE_Caching_Strategy_Adapter::caching_utility (void) -{ - return this->implementation_->caching_utility (); -} - -template ACE_INLINE void -ACE_Caching_Strategy_Adapter::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Caching_Strategy_Adapter::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -////////////////////////////////////////////////////////////////////////////////// - -template ACE_INLINE ATTRIBUTES -ACE_LRU_Caching_Strategy::attributes (void) -{ - return this->timer_; -} - -template ACE_INLINE double -ACE_LRU_Caching_Strategy::purge_percent (void) -{ - return this->purge_percent_; -} - -template ACE_INLINE void -ACE_LRU_Caching_Strategy::purge_percent (double percentage) -{ - this->purge_percent_ = percentage; -} - -template ACE_INLINE int -ACE_LRU_Caching_Strategy::notify_bind ( - int result, - const ATTRIBUTES & /* attr */) -{ - if (result == 0) - ++this->timer_; - - return result; -} - -template ACE_INLINE int -ACE_LRU_Caching_Strategy::notify_find ( - int result, - ATTRIBUTES &attr) -{ - if (result == 0) - { - attr = this->timer_; - ++this->timer_; - } - - return result; -} - -template ACE_INLINE int -ACE_LRU_Caching_Strategy::notify_unbind ( - int result, - const ATTRIBUTES & /* attr */) -{ - return result; -} - -template ACE_INLINE int -ACE_LRU_Caching_Strategy::notify_trybind ( - int result, - ATTRIBUTES & /* attr */) -{ - return result; -} - -template ACE_INLINE int -ACE_LRU_Caching_Strategy::notify_rebind ( - int result, - const ATTRIBUTES & /* attr */) -{ - if (result == 0) - ++this->timer_; - - return result; -} - -template ACE_INLINE CACHING_UTILITY & -ACE_LRU_Caching_Strategy::caching_utility (void) -{ - return this->caching_utility_; -} - -template ACE_INLINE void -ACE_LRU_Caching_Strategy::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_LRU_Caching_Strategy::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("timer_ = %d "), this->timer_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -////////////////////////////////////////////////////////////////////////////////// - -template ACE_INLINE ATTRIBUTES -ACE_LFU_Caching_Strategy::attributes (void) -{ - return 0; -} - -template ACE_INLINE double -ACE_LFU_Caching_Strategy::purge_percent (void) -{ - return this->purge_percent_; -} - -template ACE_INLINE void -ACE_LFU_Caching_Strategy::purge_percent (double percentage) -{ - this->purge_percent_ = percentage; -} - -template ACE_INLINE int -ACE_LFU_Caching_Strategy::notify_bind (int result, - const ATTRIBUTES & /* attr */) -{ - - return result; -} - -template ACE_INLINE int -ACE_LFU_Caching_Strategy::notify_find (int result, - ATTRIBUTES &attr) -{ - if (result == 0) - ++attr; - - return result; -} - -template ACE_INLINE int -ACE_LFU_Caching_Strategy::notify_trybind (int result, - ATTRIBUTES & /* attr */) -{ - return result; -} - -template ACE_INLINE int -ACE_LFU_Caching_Strategy::notify_rebind (int result, - const ATTRIBUTES & /* attr */) -{ - return result; -} - -template ACE_INLINE int -ACE_LFU_Caching_Strategy::notify_unbind (int result, - const ATTRIBUTES & /* attr */) -{ - return result; -} - -template ACE_INLINE CACHING_UTILITY & -ACE_LFU_Caching_Strategy::caching_utility (void) -{ - return this->caching_utility_; -} - -template ACE_INLINE void -ACE_LFU_Caching_Strategy::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_LFU_Caching_Strategy::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -////////////////////////////////////////////////////////////////////////////////////// - -template ACE_INLINE ATTRIBUTES -ACE_FIFO_Caching_Strategy::attributes (void) -{ - return this->order_; -} - -template ACE_INLINE double -ACE_FIFO_Caching_Strategy::purge_percent (void) -{ - return this->purge_percent_; -} - -template ACE_INLINE void -ACE_FIFO_Caching_Strategy::purge_percent (double percentage) -{ - this->purge_percent_ = percentage; -} - -template ACE_INLINE int -ACE_FIFO_Caching_Strategy::notify_bind (int result, - const ATTRIBUTES &attr) -{ - ACE_UNUSED_ARG (attr); - - if (result == 0) - ++this->order_; - - return result; -} - -template ACE_INLINE int -ACE_FIFO_Caching_Strategy::notify_find (int result, - ATTRIBUTES &attr) -{ - ACE_UNUSED_ARG (attr); - - return result; -} - -template ACE_INLINE int -ACE_FIFO_Caching_Strategy::notify_unbind (int result, - const ATTRIBUTES &attr) -{ - ACE_UNUSED_ARG (attr); - - return result; -} - -template ACE_INLINE int -ACE_FIFO_Caching_Strategy::notify_trybind (int result, - ATTRIBUTES &attr) -{ - ACE_UNUSED_ARG (attr); - - return result; -} - -template ACE_INLINE int -ACE_FIFO_Caching_Strategy::notify_rebind (int result, - const ATTRIBUTES &attr) -{ - ACE_UNUSED_ARG (attr); - - if (result == 0) - ++this->order_; - - return result; -} - -template ACE_INLINE CACHING_UTILITY & -ACE_FIFO_Caching_Strategy::caching_utility (void) -{ - return this->caching_utility_; -} - -template ACE_INLINE void -ACE_FIFO_Caching_Strategy::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_FIFO_Caching_Strategy::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("order_ = %d "), this->order_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -////////////////////////////////////////////////////////////////////////////////// - -template ACE_INLINE ATTRIBUTES -ACE_Null_Caching_Strategy::attributes (void) -{ - return 0; -} - -template ACE_INLINE double -ACE_Null_Caching_Strategy::purge_percent (void) -{ - return 0; -} - -template ACE_INLINE void -ACE_Null_Caching_Strategy::purge_percent (double percentage) -{ - ACE_UNUSED_ARG (percentage); -} - -template ACE_INLINE int -ACE_Null_Caching_Strategy::notify_bind (int result, - const ATTRIBUTES &attr) -{ - ACE_UNUSED_ARG (attr); - - return result; -} - -template ACE_INLINE int -ACE_Null_Caching_Strategy::notify_find (int result, - ATTRIBUTES &attr) -{ - ACE_UNUSED_ARG (attr); - - return result; -} - -template ACE_INLINE int -ACE_Null_Caching_Strategy::notify_unbind (int result, - const ATTRIBUTES &attr) -{ - ACE_UNUSED_ARG (attr); - - return result; -} - -template ACE_INLINE int -ACE_Null_Caching_Strategy::notify_trybind (int result, - ATTRIBUTES &attr) -{ - ACE_UNUSED_ARG (attr); - - return result; -} - -template ACE_INLINE int -ACE_Null_Caching_Strategy::notify_rebind (int result, - const ATTRIBUTES &attr) -{ - ACE_UNUSED_ARG (attr); - - return result; -} - -template ACE_INLINE CACHING_UTILITY & -ACE_Null_Caching_Strategy::caching_utility (void) -{ - return this->caching_utility_; -} - -template ACE_INLINE void -ACE_Null_Caching_Strategy::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Null_Caching_Strategy::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -////////////////////////////////////////////////////////////////////////////////// diff --git a/deps/acelite/ace/Caching_Utility_T.cpp b/deps/acelite/ace/Caching_Utility_T.cpp deleted file mode 100644 index aa344562d..000000000 --- a/deps/acelite/ace/Caching_Utility_T.cpp +++ /dev/null @@ -1,498 +0,0 @@ -#ifndef ACE_CACHING_UTILITY_T_CPP -#define ACE_CACHING_UTILITY_T_CPP - -#include "ace/Caching_Utility_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/ACE.h" -#include "ace/Min_Max.h" -#include "ace/OS_Memory.h" -#include "ace/Recyclable.h" - -////////////////////////////////////////////////////////////////////////////// - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Pair_Caching_Utility::ACE_Pair_Caching_Utility (ACE_Cleanup_Strategy *cleanup_strategy, - bool delete_cleanup_strategy) - : cleanup_strategy_ (cleanup_strategy), - delete_cleanup_strategy_ (delete_cleanup_strategy) -{ - if (cleanup_strategy == 0) - { - ACE_NEW (this->cleanup_strategy_, - CLEANUP_STRATEGY); - this->delete_cleanup_strategy_ = true; - } -} - -template -ACE_Pair_Caching_Utility::~ACE_Pair_Caching_Utility (void) -{ - if (this->delete_cleanup_strategy_) - delete this->cleanup_strategy_; -} - -template int -ACE_Pair_Caching_Utility::clear_cache (CONTAINER &container, - double purge_percent) -{ - // Check that the purge_percent is non-zero. - if (ACE::is_equal (purge_percent, 0.0)) - return 0; - - // Get the number of entries in the container. - size_t current_map_size = container.current_size (); - - // Also whether the number of entries in the cache! - // Oops! then there is no way out but exiting. So return an error. - if (current_map_size == 0) - return 0; - - // Calculate the no of entries to remove from the cache depending - // upon the . - size_t const entries_to_remove - = ACE_MAX (static_cast (1), - static_cast (static_cast (purge_percent) - / 100 * current_map_size)); - KEY *key_to_remove = 0; - VALUE *value_to_remove = 0; - - for (size_t i = 0; i < entries_to_remove ; ++i) - { - this->minimum (container, - key_to_remove, - value_to_remove); - - // Simply verifying that the key is non-zero. - // This is important for strategies where the minimum - // entry cant be found due to constraints on the type of entry - // to remove. - if (key_to_remove == 0) - return 0; - - if (this->cleanup_strategy_->cleanup (container, - key_to_remove, - value_to_remove) == -1) - return -1; - - } - - return 0; -} - -template void -ACE_Pair_Caching_Utility::minimum (CONTAINER &container, - KEY *&key_to_remove, - VALUE *&value_to_remove) -{ - // Starting values. - ITERATOR iter = container.begin (); - ITERATOR end = container.end (); - ATTRIBUTES min = (*iter).int_id_.second; - key_to_remove = &(*iter).ext_id_; - value_to_remove = &(*iter).int_id_; - - // The iterator moves thru the container searching for the entry - // with the lowest ATTRIBUTES. - for (++iter; - iter != end; - ++iter) - { - if (min > (*iter).int_id_.second) - { - // Ah! an item with lower ATTTRIBUTES... - min = (*iter).int_id_.second; - key_to_remove = &(*iter).ext_id_; - value_to_remove = &(*iter).int_id_; - } - } -} - -//////////////////////////////////////////////////////////////////////////////////////////////////////// - -template -ACE_Recyclable_Handler_Caching_Utility::ACE_Recyclable_Handler_Caching_Utility (ACE_Cleanup_Strategy *cleanup_strategy, - bool delete_cleanup_strategy) - : cleanup_strategy_ (cleanup_strategy), - delete_cleanup_strategy_ (delete_cleanup_strategy) -{ - if (cleanup_strategy == 0) - { - ACE_NEW (this->cleanup_strategy_, - CLEANUP_STRATEGY); - this->delete_cleanup_strategy_ = true; - } -} - -template -ACE_Recyclable_Handler_Caching_Utility::~ACE_Recyclable_Handler_Caching_Utility (void) -{ - if (this->delete_cleanup_strategy_) - delete this->cleanup_strategy_; -} - -template int -ACE_Recyclable_Handler_Caching_Utility::clear_cache (CONTAINER &container, - double purge_percent) -{ - // Check that the purge_percent is non-zero. - if (ACE::is_equal (purge_percent, 0.0)) - return 0; - - // Get the number of entries in the container. - size_t current_map_size = container.current_size (); - - // Also whether the number of entries in the cache is just one! - // Oops! then there is no way out but exiting. So return an error. - // if (current_map_size <= 1) - if (current_map_size == 0) - return 0; - - // Calculate the no of entries to remove from the cache depending - // upon the . - size_t const entries_to_remove - = ACE_MAX (static_cast (1), - static_cast (static_cast (purge_percent) - / 100 * current_map_size)); - - KEY *key_to_remove = 0; - VALUE *value_to_remove = 0; - - for (size_t i = 0; i < entries_to_remove ; ++i) - { - this->minimum (container, - key_to_remove, - value_to_remove); - - // Simply verifying that the key is non-zero. - // This is important for strategies where the minimum - // entry cant be found due to constraints on the type of entry - // to remove. - if (key_to_remove == 0) - return 0; - - if (this->cleanup_strategy_->cleanup (container, - key_to_remove, - value_to_remove) == -1) - return -1; - } - - return 0; -} - -template void -ACE_Recyclable_Handler_Caching_Utility::minimum (CONTAINER &container, - KEY *&key_to_remove, - VALUE *&value_to_remove) -{ - // Starting values. - ITERATOR end = container.end (); - ITERATOR iter = container.begin (); - ATTRIBUTES min = (*iter).int_id_.second; - key_to_remove = 0; - value_to_remove = 0; - // Found the minimum entry to be purged? - int found = 0; - - // The iterator moves thru the container searching for the entry - // with the lowest ATTRIBUTES. - for (; - iter != end; - ++iter) - { - // If the entry isnt IDLE_AND_PURGABLE continue until you reach - // the first entry which can be purged. This is the minimum with - // which you will compare the rest of the purgable entries. - if ((*iter).ext_id_.recycle_state () == ACE_RECYCLABLE_IDLE_AND_PURGABLE || - (*iter).ext_id_.recycle_state () == ACE_RECYCLABLE_PURGABLE_BUT_NOT_IDLE) - { - if (found == 0) - { - min = (*iter).int_id_.second; - key_to_remove = &(*iter).ext_id_; - value_to_remove = &(*iter).int_id_; - found = 1; - } - else - { - // Ah! an entry with lower ATTTRIBUTES... - if (min > (*iter).int_id_.second) - { - min = (*iter).int_id_.second; - key_to_remove = &(*iter).ext_id_; - value_to_remove = &(*iter).int_id_; - } - } - } - } -} - -//////////////////////////////////////////////////////////////////////////////// - -template -ACE_Refcounted_Recyclable_Handler_Caching_Utility::ACE_Refcounted_Recyclable_Handler_Caching_Utility (ACE_Cleanup_Strategy *cleanup_strategy, - bool delete_cleanup_strategy) - : cleanup_strategy_ (cleanup_strategy), - delete_cleanup_strategy_ (delete_cleanup_strategy), - marked_as_closed_entries_ (0) -{ - if (cleanup_strategy == 0) - { - ACE_NEW (this->cleanup_strategy_, - CLEANUP_STRATEGY); - this->delete_cleanup_strategy_ = true; - } -} - -template -ACE_Refcounted_Recyclable_Handler_Caching_Utility::~ACE_Refcounted_Recyclable_Handler_Caching_Utility (void) -{ - if (this->delete_cleanup_strategy_) - delete this->cleanup_strategy_; -} - -template int -ACE_Refcounted_Recyclable_Handler_Caching_Utility::clear_cache (CONTAINER &container, - double purge_percent) -{ - // Check that the purge_percent is non-zero. - if (ACE::is_equal (purge_percent, 0.0)) - return 0; - - // Get the number of entries in the container which can be considered for purging. - size_t const available_entries = - container.current_size () - this->marked_as_closed_entries_; - - // Also whether the number of entries in the cache zero. - // Oops! then there is no way out but exiting. - if (available_entries <= 0) - return 0; - - // Calculate the no of entries to remove from the cache depending - // upon the . - size_t entries_to_remove - = ACE_MAX (static_cast (1), - static_cast (static_cast (purge_percent) - / 100 * available_entries)); - - if (entries_to_remove >= available_entries || entries_to_remove == 0) - entries_to_remove = available_entries - 1; - - KEY *key_to_remove = 0; - VALUE *value_to_remove = 0; - - for (size_t i = 0; i < entries_to_remove ; ++i) - { - this->minimum (container, - key_to_remove, - value_to_remove); - - // Simply verifying that the key is non-zero. - // This is important for strategies where the minimum - // entry cant be found due to constraints on the type of entry - // to remove. - if (key_to_remove == 0) - return 0; - - if (this->cleanup_strategy_->cleanup (container, - key_to_remove, - value_to_remove) == -1) - return -1; - - ++this->marked_as_closed_entries_; - } - - return 0; -} - -template void -ACE_Refcounted_Recyclable_Handler_Caching_Utility::minimum (CONTAINER &container, - KEY *&key_to_remove, - VALUE *&value_to_remove) -{ - // Starting values. - ITERATOR end = container.end (); - ITERATOR iter = container.begin (); - ATTRIBUTES min = (*iter).int_id_.second (); - key_to_remove = 0; - value_to_remove = 0; - // Found the minimum entry to be purged? - int found = 0; - - // The iterator moves thru the container searching for the entry - // with the lowest ATTRIBUTES. - for (; - iter != end; - ++iter) - { - // If the entry isnt IDLE_AND_PURGABLE continue until you reach - // the first entry which can be purged. This is the minimum with - // which you will compare the rest of the purgable entries. - if ((*iter).ext_id_.recycle_state () == ACE_RECYCLABLE_IDLE_AND_PURGABLE || - (*iter).ext_id_.recycle_state () == ACE_RECYCLABLE_PURGABLE_BUT_NOT_IDLE) - { - if (found == 0) - { - min = (*iter).int_id_.second (); - key_to_remove = &(*iter).ext_id_; - value_to_remove = &(*iter).int_id_; - found = 1; - } - else - { - // Ah! an entry with lower ATTTRIBUTES... - if (min > (*iter).int_id_.second ()) - { - min = (*iter).int_id_.second (); - key_to_remove = &(*iter).ext_id_; - value_to_remove = &(*iter).int_id_; - } - } - } - } -} - -//////////////////////////////////////////////////////////////////////////////// - -template -ACE_Handler_Caching_Utility::ACE_Handler_Caching_Utility (ACE_Cleanup_Strategy *cleanup_strategy, - bool delete_cleanup_strategy) - : cleanup_strategy_ (cleanup_strategy), - delete_cleanup_strategy_ (delete_cleanup_strategy) -{ - if (cleanup_strategy == 0) - { - ACE_NEW (this->cleanup_strategy_, - CLEANUP_STRATEGY); - this->delete_cleanup_strategy_ = true; - } -} - -template -ACE_Handler_Caching_Utility::~ACE_Handler_Caching_Utility (void) -{ - if (this->delete_cleanup_strategy_) - delete this->cleanup_strategy_; -} - -template int -ACE_Handler_Caching_Utility::clear_cache (CONTAINER &container, - double purge_percent) -{ - // Check that the purge_percent is non-zero. - if (ACE::is_equal (purge_percent, 0.0)) - return 0; - - // Get the number of entries in the container. - size_t current_map_size = container.current_size (); - - // Also whether the number of entries in the cache is just one! - // Oops! then there is no way out but exiting. So return an error. - if (current_map_size == 0) - return 0; - - // Calculate the no of entries to remove from the cache depending - // upon the . - size_t entries_to_remove - = ACE_MAX (static_cast (1), - static_cast (static_cast (purge_percent) - / 100 * current_map_size)); - - KEY *key_to_remove = 0; - VALUE *value_to_remove = 0; - - for (size_t i = 0; i < entries_to_remove ; ++i) - { - this->minimum (container, - key_to_remove, - value_to_remove); - - if (this->cleanup_strategy_->cleanup (container, - key_to_remove, - value_to_remove) == -1) - return -1; - } - - return 0; -} - -template void -ACE_Handler_Caching_Utility::minimum (CONTAINER &container, - KEY *&key_to_remove, - VALUE *&value_to_remove) -{ - // Starting values. - ITERATOR iter = container.begin (); - ITERATOR end = container.end (); - ATTRIBUTES min = (*iter).int_id_->caching_attributes (); - key_to_remove = &(*iter).ext_id_; - value_to_remove = &(*iter).int_id_; - - // The iterator moves thru the container searching for the entry - // with the lowest ATTRIBUTES. - for (++iter; - iter != end; - ++iter) - { - if (min > (*iter).int_id_->caching_attributes () && - (*iter).int_id_->active () != 1) - { - // Ah! an item with lower ATTTRIBUTES... - min = (*iter).int_id_->caching_attributes (); - key_to_remove = &(*iter).ext_id_; - value_to_remove = &(*iter).int_id_; - } - } -} - -//////////////////////////////////////////////////////////////////////////////////////////////////////// - -template -ACE_Null_Caching_Utility::ACE_Null_Caching_Utility (ACE_Cleanup_Strategy *cleanup_strategy, - bool delete_cleanup_strategy) - : cleanup_strategy_ (cleanup_strategy), - delete_cleanup_strategy_ (delete_cleanup_strategy) -{ - if (cleanup_strategy == 0) - { - ACE_NEW (this->cleanup_strategy_, - CLEANUP_STRATEGY); - this->delete_cleanup_strategy_ = true; - } -} - -template -ACE_Null_Caching_Utility::~ACE_Null_Caching_Utility (void) -{ - if (this->delete_cleanup_strategy_) - delete this->cleanup_strategy_; -} - -template int -ACE_Null_Caching_Utility::clear_cache (CONTAINER &container, - double purge_percent) -{ - ACE_UNUSED_ARG (container); - ACE_UNUSED_ARG (purge_percent); - - return 0; -} - -template void -ACE_Null_Caching_Utility::minimum (CONTAINER &container, - KEY *&key_to_remove, - VALUE *&value_to_remove) -{ - ACE_UNUSED_ARG (container); - ACE_UNUSED_ARG (key_to_remove); - ACE_UNUSED_ARG (value_to_remove); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_CACHING_UTILITY_T_CPP */ diff --git a/deps/acelite/ace/Caching_Utility_T.h b/deps/acelite/ace/Caching_Utility_T.h deleted file mode 100644 index ac046b974..000000000 --- a/deps/acelite/ace/Caching_Utility_T.h +++ /dev/null @@ -1,306 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Caching_Utility_T.h - * - * @author Kirthika Parameswaran - */ -//============================================================================= - -#ifndef ACE_CACHING_UTILITY_H -#define ACE_CACHING_UTILITY_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Global_Macros.h" -#include "ace/Cleanup_Strategies_T.h" -#include "ace/Copy_Disabled.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Pair_Caching_Utility - * - * @brief Defines a helper class for the Caching Strategies. - * - * This class defines the methods commonly used by the different - * caching strategies. For instance: clear_cache() method which - * decides and purges the entry from the container. @note This - * class helps in the caching_strategies using a container - * containing entries of > - * kind. The attributes helps in deciding the entries to be - * purged. The Cleanup_Strategy is the callback class to which the - * entries to be cleaned up will be delegated. - */ -template -class ACE_Pair_Caching_Utility : private ACE_Copy_Disabled -{ -public: - typedef ACE_Cleanup_Strategy CLEANUP_STRATEGY; - - /// Constructor. - ACE_Pair_Caching_Utility (ACE_Cleanup_Strategy *cleanup_strategy = 0, - bool delete_cleanup_strategy = false); - - /// Destructor. - ~ACE_Pair_Caching_Utility (void); - - /** - * Purge entries from the @a container. The Cleanup_Strategy will do the - * actual job of cleanup once the entries to be cleaned up are decided. - */ - int clear_cache (CONTAINER &container, double purge_percent); - -protected: - - /// Find the entry with minimum caching attributes. - void minimum (CONTAINER &container, - KEY *&key_to_remove, - VALUE *&value_to_remove); - - /// The cleanup strategy which can be used to destroy the entries of - /// the container. - CLEANUP_STRATEGY *cleanup_strategy_; - - /// Whether the cleanup_strategy should be destroyed or not. - bool delete_cleanup_strategy_; -}; - -/** - * @class ACE_Recyclable_Handler_Caching_Utility - * - * @brief Defines a helper class for the Caching Strategies. - * - * This class defines the methods commonly used by the different - * caching strategies. For instance: clear_cache() method which - * decides and purges the entry from the container. @note This - * class helps in the caching_strategies using a container - * containing entries of kind. The attributes - * helps in deciding the entries to be purged. The - * Cleanup_Strategy is the callback class to which the entries to - * be cleaned up will be delegated. - */ -template -class ACE_Recyclable_Handler_Caching_Utility : private ACE_Copy_Disabled -{ -public: - typedef ACE_Recyclable_Handler_Cleanup_Strategy CLEANUP_STRATEGY; - typedef ACE_Cleanup_Strategy CLEANUP_STRATEGY_BASE; - - /// Constructor. - ACE_Recyclable_Handler_Caching_Utility (ACE_Cleanup_Strategy *cleanup_strategy = 0, - bool delete_cleanup_strategy = false); - - /// Destructor. - ~ACE_Recyclable_Handler_Caching_Utility (void); - - /** - * Purge entries from the @a container. The Cleanup_Strategy will do - * the actual job of cleanup once the entries to be cleaned up are - * decided. - */ - int clear_cache (CONTAINER &container, - double purge_percent); - -protected: - - /// Find the entry with minimum caching attributes. - void minimum (CONTAINER &container, - KEY *&key_to_remove, - VALUE *&value_to_remove); - - /// This is the default Cleanup Strategy for this utility. - CLEANUP_STRATEGY_BASE *cleanup_strategy_; - - /// Whether the cleanup_strategy should be destroyed or not. - bool delete_cleanup_strategy_; -}; - -/** - * @class ACE_Refcounted_Recyclable_Handler_Caching_Utility - * - * @brief Defines a helper class for the Caching Strategies. - * - * This class defines the methods commonly used by the different - * caching strategies. For instance: clear_cache () method which - * decides and purges the entry from the container. @note This - * class helps in the caching_strategies using a container - * containing entries of kind. The attributes helps in - * deciding the entries to be purged. The Cleanup_Strategy is the - * callback class to which the entries to be cleaned up will be - * delegated. - */ -template -class ACE_Refcounted_Recyclable_Handler_Caching_Utility : private ACE_Copy_Disabled -{ -public: - typedef ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy CLEANUP_STRATEGY; - typedef ACE_Cleanup_Strategy CLEANUP_STRATEGY_BASE; - - /// Constructor. - ACE_Refcounted_Recyclable_Handler_Caching_Utility (ACE_Cleanup_Strategy *cleanup_strategy = 0, - bool delete_cleanup_strategy = false); - - /// Destructor. - ~ACE_Refcounted_Recyclable_Handler_Caching_Utility (void); - - /** - * Purge entries from the @a container. The Cleanup_Strategy will do - * the actual job of cleanup once the entries to be cleaned up are - * decided. - */ - int clear_cache (CONTAINER &container, - double purge_percent); - -protected: - - /// Find the entry with minimum caching attributes. - void minimum (CONTAINER &container, - KEY *&key_to_remove, - VALUE *&value_to_remove); - - /// This is the default Cleanup Strategy for this utility. - CLEANUP_STRATEGY_BASE *cleanup_strategy_; - - /// Whether the cleanup_strategy should be destroyed or not. - bool delete_cleanup_strategy_; - - /** - * This figure denotes the number of entries are there in the - * container which have been marked as closed already but might - * not have been unbound from the container. - */ - size_t marked_as_closed_entries_; -}; - -/** - * @class ACE_Handler_Caching_Utility - * - * @brief Defines a helper class for the Caching Strategies. - * - * This class defines the methods commonly used by the different - * caching strategies. For instance: clear_cache() method which - * decides and purges the entry from the container. @note This - * class helps in the caching_strategies using a container - * containing entries of kind where the HANDLER - * contains the caching attributes which help in deciding the - * entries to be purged. The Cleanup_Strategy is the callback - * class to which the entries to be cleaned up will be delegated. - */ -template -class ACE_Handler_Caching_Utility : private ACE_Copy_Disabled -{ -public: - typedef ACE_Handler_Cleanup_Strategy CLEANUP_STRATEGY; - typedef ACE_Cleanup_Strategy CLEANUP_STRATEGY_BASE; - - /// Constructor. - ACE_Handler_Caching_Utility (ACE_Cleanup_Strategy *cleanup_strategy = 0, - bool delete_cleanup_strategy = false); - - /// Destructor. - ~ACE_Handler_Caching_Utility (void); - - /** - * Purge entries from the @a container. The Cleanup_Strategy will do - * the actual job of cleanup once the entries to be cleaned up are - * decided. - */ - int clear_cache (CONTAINER &container, - double purge_percent); - -protected: - - /** - * Find the entry with minimum caching attributes. This is handler - * specific since this utility is to be used very specifically for - * handler who have caching_attributes for server side acched - * connection management. - */ - void minimum (CONTAINER &container, - KEY *&key_to_remove, - VALUE *&value_to_remove); - - /// The cleanup strategy which can be used to destroy the entries of - /// the container. - CLEANUP_STRATEGY_BASE *cleanup_strategy_; - - /// Whether the cleanup_strategy should be destroyed or not. - bool delete_cleanup_strategy_; -}; - -/** - * @class ACE_Null_Caching_Utility - * - * @brief Defines a dummy helper class for the Caching Strategies. - * - * This class defines the methods commonly used by the different - * caching strategies. For instance: clear_cache() method which - * decides and purges the entry from the container. @note This - * class is be used with the Null_Caching_Strategy. The - * Cleanup_Strategy is the callback class to which the entries to - * be cleaned up will be delegated. - */ -template -class ACE_Null_Caching_Utility : private ACE_Copy_Disabled -{ -public: - typedef ACE_Null_Cleanup_Strategy CLEANUP_STRATEGY; - typedef ACE_Cleanup_Strategy CLEANUP_STRATEGY_BASE; - - /// Constructor. - ACE_Null_Caching_Utility (ACE_Cleanup_Strategy *cleanup_strategy = 0, - bool delete_cleanup_strategy = false); - - /// Destructor. - ~ACE_Null_Caching_Utility (void); - - /** - * Purge entries from the @a container. The Cleanup_Strategy will do - * the actual job of cleanup once the entries to be cleaned up are - * decided. @note Here it is a no-op. - */ - int clear_cache (CONTAINER &container, - double purge_percent); - -protected: - - /** - * Find the entry with minimum caching attributes. This is handler - * specific since this utility is to be used very specifically for - * handler who have caching_attributes for server side acched - * connection management.@note Here it is a no-op. - */ - void minimum (CONTAINER &container, - KEY *&key_to_remove, - VALUE *&value_to_remove); - - /// The cleanup strategy which can be used to destroy the entries of - /// the container. - CLEANUP_STRATEGY_BASE *cleanup_strategy_; - - /// Whether the cleanup_strategy should be destroyed or not. - bool delete_cleanup_strategy_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Caching_Utility_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Caching_Utility_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_CACHING_UTILITY_H */ diff --git a/deps/acelite/ace/Capabilities.cpp b/deps/acelite/ace/Capabilities.cpp deleted file mode 100644 index 9ffceda2a..000000000 --- a/deps/acelite/ace/Capabilities.cpp +++ /dev/null @@ -1,352 +0,0 @@ -#include "ace/Capabilities.h" -#include "ace/OS_NS_ctype.h" -#include "ace/OS_Memory.h" -#include "ace/OS_NS_string.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Capabilities.inl" -#endif /* !__ACE_INLINE__ */ - -#include "ace/OS_NS_stdio.h" - -#define ACE_ESC ((ACE_TCHAR)0x1b) - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_CapEntry::~ACE_CapEntry (void) -{ -} - -ACE_Capabilities::ACE_Capabilities (void) - : caps_ () -{ -} - -ACE_Capabilities::~ACE_Capabilities (void) -{ - this->resetcaps (); -} - -const ACE_TCHAR * -ACE_Capabilities::parse (const ACE_TCHAR *buf, ACE_TString &cap) -{ - while (*buf != ACE_TEXT ('\0') && *buf != ACE_TEXT (',')) - { - if (*buf == ACE_TEXT ('\\')) - { - ++buf; - if (*buf == ACE_TEXT ('E') || *buf == ACE_TEXT ('e')) - { - cap += ACE_ESC; - ++buf; - continue; - } - else if (*buf == ACE_TEXT ('r')) - { - cap += ACE_TEXT ('\r'); - ++buf; - continue; - } - else if (*buf == ACE_TEXT ('n')) - { - cap += ACE_TEXT ('\n'); - ++buf; - continue; - } - else if (*buf == ACE_TEXT ('t')) - { - cap += ACE_TEXT ('\t'); - ++buf; - continue; - } - else if (*buf == ACE_TEXT ('\\')) - { - cap += *buf++; - continue; - } - if (ACE_OS::ace_isdigit(*buf)) - { - // @@ UNICODE Does this work with unicode? - int oc = 0; - for (int i = 0; - i < 3 && *buf && ACE_OS::ace_isdigit (*buf); - i++) - oc = oc * 8 + (*buf++ - ACE_TEXT ('0')); - - cap += (ACE_TCHAR) oc; - continue; - } - } - cap += *buf++; - } - return buf; -} - -const ACE_TCHAR * -ACE_Capabilities::parse (const ACE_TCHAR *buf, int &cap) -{ - int n = 0; - - while (*buf && ACE_OS::ace_isdigit (*buf)) - n = n * 10 + (*buf++ - ACE_TEXT ('0')); - - cap = n; - - return buf; -} - -void -ACE_Capabilities::resetcaps (void) -{ - for (CAPABILITIES_MAP::ITERATOR iter (this->caps_); - !iter.done (); - iter.advance ()) - { - CAPABILITIES_MAP::ENTRY *entry = 0; - iter.next (entry); - delete entry->int_id_; - } - - this->caps_.close (); - this->caps_.open (); -} - -int -ACE_Capabilities::fillent (const ACE_TCHAR *buf) -{ - this->resetcaps (); - while (*buf) - { - ACE_TString s; - int n; - ACE_TString name; - ACE_CapEntry *ce; - - // Skip blanks - while (*buf && ACE_OS::ace_isspace(*buf)) buf++; - // If we get end of line return - - if (*buf == ACE_TEXT ('\0')) - break; - - if (*buf == ACE_TEXT ('#')) - { - while (*buf && *buf != ACE_TEXT ('\n')) - buf++; - if (*buf == ACE_TEXT ('\n')) - buf++; - continue; - } - while(*buf && *buf != ACE_TEXT ('=') - && *buf!= ACE_TEXT ('#') - && *buf != ACE_TEXT (',')) - name += *buf++; - - // If name is null. - switch (*buf) - { - case ACE_TEXT ('='): - // String property - buf = this->parse (buf + 1, s); - ACE_NEW_RETURN (ce, - ACE_StringCapEntry (s), - -1); - if (this->caps_.bind (name, ce) == -1) - { - delete ce; - return -1; - } - break; - case ACE_TEXT ('#'): - // Integer property - buf = this->parse (buf + 1, n); - ACE_NEW_RETURN (ce, - ACE_IntCapEntry (n), - -1); - if (this->caps_.bind (name, ce) == -1) - { - delete ce; - return -1; - } - break; - case ACE_TEXT (','): - // Boolean - ACE_NEW_RETURN (ce, - ACE_BoolCapEntry (1), - -1); - if (this->caps_.bind (name, ce) == -1) - { - delete ce; - return -1; - } - break; - default: - return 0; - } - - if (*buf++ != ACE_TEXT (',')) - return -1; - } - - return 0; -} - -int -ACE_Capabilities::is_entry (const ACE_TCHAR *name, const ACE_TCHAR *line) -{ - for (;;) - { - // Skip blanks or irrelevant characters - while (*line && ACE_OS::ace_isspace(*line)) - ++line; - - // End of line reached - if (*line == ACE_TEXT ('\0')) - break; - - // Build the entry name - ACE_TString nextname; - while (*line && *line != ACE_TEXT ('|') && *line != ACE_TEXT (',')) - nextname += *line++; - - // We have found the required entry? - if (ACE_OS::strcmp (nextname.c_str (), name) == 0) - return 1; - - // Skip puntuaction char if neccesary. - if (*line == ACE_TEXT ('|') || *line == ACE_TEXT (',')) - ++line; - else - { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("Invalid entry\n"))); - break; - } - } - return 0; -} - -int -ACE_Capabilities::getline (FILE *fp, ACE_TString &line) -{ - int ch; - - line.set (0, 0); - - while ((ch = ACE_OS::fgetc (fp)) != EOF && ch != ACE_TEXT ('\n')) - line += (ACE_TCHAR) ch; - - if (ch == EOF && line.length () == 0) - return -1; - else - return 0; -} - -int -ACE_Capabilities::getval (const ACE_TCHAR *keyname, ACE_TString &val) -{ - ACE_CapEntry* cap = 0; - if (this->caps_.find (keyname, cap) == -1) - return -1; - - ACE_StringCapEntry *scap = - dynamic_cast (cap); - if (scap == 0) - return -1; - - val = scap->getval (); - return 0; -} - -int -ACE_Capabilities::getval (const ACE_TCHAR *keyname, int &val) -{ - ACE_CapEntry *cap = 0; - if (this->caps_.find (keyname, cap) == -1) - return -1; - - ACE_IntCapEntry *icap = - dynamic_cast (cap); - if (icap != 0) - { - val = icap->getval (); - return 0; - } - - ACE_BoolCapEntry *bcap = - dynamic_cast (cap); - - if (bcap == 0) - return -1; - - val = bcap->getval (); - return 0; -} - -static int -is_empty (const ACE_TCHAR *line) -{ - while (*line && ACE_OS::ace_isspace (*line)) - ++line; - - return *line == ACE_TEXT ('\0') || *line == ACE_TEXT ('#'); -} - -static int -is_line (const ACE_TCHAR *line) -{ - while (*line && ACE_OS::ace_isspace (*line)) - ++line; - - return *line != ACE_TEXT ('\0'); -} - -int -ACE_Capabilities::getent (const ACE_TCHAR *fname, const ACE_TCHAR *name) -{ - FILE *fp = ACE_OS::fopen (fname, ACE_TEXT ("r")); - - if (fp == 0) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("Can't open %s file\n"), - fname), - -1); - - int done; - ACE_TString line; - - while (0 == (done = (this->getline (fp, line) == -1)) - && is_empty (line.c_str ())) - continue; - - while (!done) - { - ACE_TString newline; - ACE_TString description; - - while (0 == (done = (this->getline (fp, newline) == -1))) - if (is_line (newline.c_str ())) - description += newline; - else - break; - - if (this->is_entry (name, line.c_str())) - { - ACE_OS::fclose (fp); - return this->fillent (description.c_str ()); - } - - line = newline; - while (!done && is_empty (line.c_str ())) - done = this->getline (fp, line) == -1; - } - - ACE_OS::fclose (fp); - return -1; -} - -ACE_ALLOC_HOOK_DEFINE(ACE_StringCapEntry) -ACE_ALLOC_HOOK_DEFINE(ACE_IntCapEntry) -ACE_ALLOC_HOOK_DEFINE(ACE_BoolCapEntry) - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Capabilities.h b/deps/acelite/ace/Capabilities.h deleted file mode 100644 index e43ace9d2..000000000 --- a/deps/acelite/ace/Capabilities.h +++ /dev/null @@ -1,189 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Capabilities.h - * - * @author Arturo Montes - */ -//============================================================================= - - -#ifndef ACE_CAPABILITIES_H -#define ACE_CAPABILITIES_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Null_Mutex.h" -#include "ace/Hash_Map_Manager_T.h" -#include "ace/Containers.h" -#include "ace/SString.h" -#include "ace/Functor_String.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_CapEntry - * - * @brief This class is the base class for all ACE Capabilities entry - * subclasses. - * - * This class is not instantiable and does not provide accessors - * or methods. If you want to add a new kind of attribute subclass - * this class and dynamic_cast to proper subclass. - */ -class ACE_Export ACE_CapEntry -{ -public: - virtual ~ACE_CapEntry (void); - -protected: - enum - { - ACE_INTCAP = 0, - ACE_STRINGCAP = 1, - ACE_BOOLCAP = 2 - }; - - ACE_CapEntry (int captype); - -protected: - int captype_; -}; - -/** - * @class ACE_IntCapEntry - * - * @brief This class implement the ACE Integer Capability subclass. - * - * This is a container class for ACE Capabilities integer container - * values. - */ -class ACE_Export ACE_IntCapEntry : public ACE_CapEntry -{ -public: - ACE_IntCapEntry (int val); - int getval (void) const; - ACE_ALLOC_HOOK_DECLARE; - -protected: - int val_; -}; - -/** - * @class ACE_StringCapEntry - * - * @brief This class implement the ACE String Capability subclass. - * - * This is a container class for ACE Capabilities String container - * values. - */ -class ACE_Export ACE_StringCapEntry : public ACE_CapEntry -{ -public: - ACE_StringCapEntry (const ACE_TString &val); - ACE_TString getval (void) const; - ACE_ALLOC_HOOK_DECLARE; - -protected: - ACE_TString val_; -}; - -/** - * @class ACE_BoolCapEntry - * - * @brief This class implement the ACE Bool Capability subclass. - * - * This is a container class for ACE Capabilities bool container - * values. - */ -class ACE_Export ACE_BoolCapEntry : public ACE_CapEntry -{ -public: - ACE_BoolCapEntry (int val); - int getval (void) const; - ACE_ALLOC_HOOK_DECLARE; - -protected: - int val_; -}; - -/** - * @class ACE_Capabilities - * - * @brief - * This class implement the ACE Capabilities. - * - * This is a container class for ACE Capabilities - * values. Currently exist three different capability values: - * ACE_IntCapEntry (integer), ACE_BoolCapEntry (bool) and - * ACE_StringCapEntry (String). An ACE_Capabilities is a - * unordered set of pair = (String, ACE_CapEntry *). Where - * the first component is the name of capability and the second - * component is a pointer to the capability value container. A - * FILE is a container for ACE_Capabilities, the - * ACE_Capabilities has a name in the file, as a termcap file. - */ -class ACE_Export ACE_Capabilities -{ -public: - typedef ACE_Hash_Map_Manager_Ex, ACE_Equal_To, ACE_Null_Mutex> CAPABILITIES_MAP; - - /// The Constructor - ACE_Capabilities (void); - - /// The Destructor - ~ACE_Capabilities(void); - -public: - /// Get a string entry. - int getval (const ACE_TCHAR *ent, ACE_TString &val); - - /// Get an integer entry. - int getval (const ACE_TCHAR *ent, int &val); - - /// Get the ACE_Capabilities name from FILE fname and load the - /// associated capabitily entries in map. - int getent (const ACE_TCHAR *fname, const ACE_TCHAR *name); - -protected: - /// Parse an integer property - const ACE_TCHAR *parse (const ACE_TCHAR *buf, int &cap); - - /// Parse a string property - const ACE_TCHAR *parse (const ACE_TCHAR *buf, ACE_TString &cap); - - /// Fill the ACE_Capabilities with description in ent. - int fillent(const ACE_TCHAR *ent); - - /// Parse a cap entry - int parseent (const ACE_TCHAR *name, ACE_TCHAR *line); - - /// Get a line from FILE input stream - int getline (FILE* fp, - ACE_TString &line); - - /// Is a valid entry - int is_entry (const ACE_TCHAR *name, const ACE_TCHAR *line); - - /// Reset the set of capabilities - void resetcaps (void); - -private: - /// This is the set of ACE_CapEntry. - CAPABILITIES_MAP caps_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Capabilities.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* __ACE_CAPABILITIES_H__ */ diff --git a/deps/acelite/ace/Capabilities.inl b/deps/acelite/ace/Capabilities.inl deleted file mode 100644 index 0579ae6cd..000000000 --- a/deps/acelite/ace/Capabilities.inl +++ /dev/null @@ -1,49 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_CapEntry::ACE_CapEntry (int captype) - : captype_ (captype) -{ -} - -ACE_INLINE -ACE_IntCapEntry::ACE_IntCapEntry (int val) - : ACE_CapEntry (ACE_INTCAP), - val_ (val) -{ -} - -ACE_INLINE int -ACE_IntCapEntry::getval (void) const -{ - return val_; -} - -ACE_INLINE -ACE_StringCapEntry::ACE_StringCapEntry (const ACE_TString &val) - : ACE_CapEntry (ACE_STRINGCAP), - val_ (val) -{ -} - -ACE_INLINE ACE_TString -ACE_StringCapEntry::getval (void) const -{ - return val_; -} - -ACE_INLINE -ACE_BoolCapEntry::ACE_BoolCapEntry (int val) - : ACE_CapEntry (ACE_BOOLCAP), - val_(val) -{ -} - -ACE_INLINE int -ACE_BoolCapEntry::getval (void) const -{ - return val_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Cleanup.cpp b/deps/acelite/ace/Cleanup.cpp deleted file mode 100644 index 0e162c8cf..000000000 --- a/deps/acelite/ace/Cleanup.cpp +++ /dev/null @@ -1,185 +0,0 @@ -#include "ace/Cleanup.h" - -#if !defined (ACE_HAS_INLINED_OSCALLS) -# include "ace/Cleanup.inl" -#endif /* ACE_HAS_INLINED_OSCALLS */ - -#include "ace/OS_Memory.h" -#include "ace/OS_NS_string.h" -#include "ace/os_include/os_typeinfo.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -void -ACE_Cleanup::cleanup (void *) -{ - delete this; -} - -ACE_Cleanup::~ACE_Cleanup (void) -{ -} - -/*****************************************************************************/ - -extern "C" void -ACE_CLEANUP_DESTROYER_NAME (ACE_Cleanup *object, void *param) -{ - object->cleanup (param); -} - -/*****************************************************************************/ - -ACE_Cleanup_Info_Node::ACE_Cleanup_Info_Node (void) - : object_ (0), - cleanup_hook_ (0), - param_ (0), - name_ (0) -{ -} - -ACE_Cleanup_Info_Node::ACE_Cleanup_Info_Node (void *object, - ACE_CLEANUP_FUNC cleanup_hook, - void *param, - const char *name) - : object_ (object), - cleanup_hook_ (cleanup_hook), - param_ (param), - name_ (name ? ACE_OS::strdup (name) : 0) -{ -} - -ACE_Cleanup_Info_Node::~ACE_Cleanup_Info_Node (void) -{ - if (this->name_) -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free ((void *) name_); -#else - ACE_OS::free ((void *) name_); -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Cleanup_Info_Node) - -bool -ACE_Cleanup_Info_Node::operator== (const ACE_Cleanup_Info_Node &o) const -{ - return o.object_ == this->object_ - && o.cleanup_hook_ == this->cleanup_hook_ - && o.param_ == this->param_; -} - -bool -ACE_Cleanup_Info_Node::operator!= (const ACE_Cleanup_Info_Node &o) const -{ - return !(*this == o); -} - - -/*****************************************************************************/ - -ACE_OS_Exit_Info::ACE_OS_Exit_Info (void) -{ -} - -ACE_OS_Exit_Info::~ACE_OS_Exit_Info (void) -{ -} - -int -ACE_OS_Exit_Info::at_exit_i (void *object, - ACE_CLEANUP_FUNC cleanup_hook, - void *param, - const char* name) -{ - // Return -1 and sets errno if unable to allocate storage. Enqueue - // at the head and dequeue from the head to get LIFO ordering. - ACE_Cleanup_Info_Node *new_node = 0; - - ACE_NEW_RETURN (new_node, - ACE_Cleanup_Info_Node (object, cleanup_hook, param, name), - -1); - - registered_objects_.push_front (new_node); - - return 0; -} - -bool -ACE_OS_Exit_Info::find (void *object) -{ - for (ACE_Cleanup_Info_Node *iter = registered_objects_.head (); - iter != 0; - iter = iter->next ()) - { - if (iter->object () == object) - { - // The object has already been registered. - return true; - } - } - - return false; -} - -bool -ACE_OS_Exit_Info::remove (void *object) -{ - ACE_Cleanup_Info_Node *node = 0; - for (ACE_Cleanup_Info_Node *iter = registered_objects_.head (); - iter != 0; - iter = iter->next ()) - { - if (iter->object () == object) - { - node = iter; - break; - } - } - - if (node) - { - registered_objects_.remove (node); - delete node; - return true; - } - - return false; -} - - -void -ACE_OS_Exit_Info::call_hooks (void) -{ - // Call all registered cleanup hooks, in reverse order of - // registration. - for (ACE_Cleanup_Info_Node *iter = registered_objects_.pop_front (); - iter != 0; - iter = registered_objects_.pop_front ()) - { - if (iter->cleanup_hook () == reinterpret_cast ( - ACE_CLEANUP_DESTROYER_NAME)) - { - // The object is an ACE_Cleanup. - ACE_CLEANUP_DESTROYER_NAME ( - reinterpret_cast (iter->object ()), - iter->param ()); - } - else if (iter->object () == &ace_exit_hook_marker) - { - // The hook is an ACE_EXIT_HOOK. - (* reinterpret_cast (iter->cleanup_hook ())) (); - } - else - { - (*iter->cleanup_hook ()) (iter->object (), iter->param ()); - } - delete iter; - } -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Cleanup.h b/deps/acelite/ace/Cleanup.h deleted file mode 100644 index 86044c85c..000000000 --- a/deps/acelite/ace/Cleanup.h +++ /dev/null @@ -1,161 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Cleanup.h - * - * @author Douglas C. Schmidt - * @author Jesper S. M|ller - * @author and a cast of thousands... - * - * Originally in OS.h. - */ -//============================================================================= - -#ifndef ACE_CLEANUP_H -# define ACE_CLEANUP_H - -# include /**/ "ace/pre.h" - -# include "ace/config-lite.h" - -# if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -# endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include /**/ "ace/ACE_export.h" - -# include "ace/Intrusive_List.h" -# include "ace/Intrusive_List_Node.h" - -#if (defined (ACE_HAS_VERSIONED_NAMESPACE) && ACE_HAS_VERSIONED_NAMESPACE == 1) -# include "ace/Global_Macros.h" -# define ACE_CLEANUP_DESTROYER_NAME ACE_PREPROC_CONCATENATE(ACE_VERSIONED_NAMESPACE_NAME, _ace_cleanup_destroyer) -#else -# define ACE_CLEANUP_DESTROYER_NAME ace_cleanup_destroyer -#endif /* ACE_HAS_VERSIONED_NAMESPACE == 1 */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Cleanup - * - * @brief Base class for objects that are cleaned by ACE_Object_Manager. - */ -class ACE_Export ACE_Cleanup -{ -public: - /// No-op constructor. - ACE_Cleanup (void); - - /// Destructor. - virtual ~ACE_Cleanup (void); - - /// Cleanup method that, by default, simply deletes itself. - virtual void cleanup (void *param = 0); -}; - -/// Adapter for cleanup, used by ACE_Object_Manager. -extern "C" ACE_Export -void ACE_CLEANUP_DESTROYER_NAME (ACE_Cleanup *, void *param = 0); - -/** - * @class ACE_Cleanup_Info_Node - * - * @brief For maintaining a list of ACE_Cleanup_Info items. - * - * For internal use by ACE_Object_Manager. - */ -class ACE_Cleanup_Info_Node : public ACE_Intrusive_List_Node -{ -public: - ACE_Cleanup_Info_Node (void); - ACE_Cleanup_Info_Node (void *object, - ACE_CLEANUP_FUNC cleanup_hook, - void *param, - const char *name); - ~ACE_Cleanup_Info_Node (void); - - /// Equality operator. - bool operator== (const ACE_Cleanup_Info_Node &o) const; - - /// Inequality operator. - bool operator!= (const ACE_Cleanup_Info_Node &o) const; - - void* object(void); - - ACE_CLEANUP_FUNC cleanup_hook (void); - - void *param (void); - - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Point to object that gets passed into the . - void *object_; - - /// Cleanup hook that gets called back. - ACE_CLEANUP_FUNC cleanup_hook_; - - /// Parameter passed to the . - void *param_; - - /// Name of the cleanup object - const char *name_; -}; - -typedef ACE_Intrusive_List ACE_Cleanup_Info_Node_List; - -/** - * @class ACE_OS_Exit_Info - * - * @brief Hold Object Manager cleanup (exit) information. - * - * @internal - * - * For internal use by the ACE library, only. - */ -class ACE_Export ACE_OS_Exit_Info -{ -public: - /// Default constructor. - ACE_OS_Exit_Info (void); - - /// Destructor. - ~ACE_OS_Exit_Info (void); - - /// Use to register a cleanup hook. - int at_exit_i (void *object, ACE_CLEANUP_FUNC cleanup_hook, void *param, const char* name = 0); - - /// Look for a registered cleanup hook object. Returns true if already - /// registered, false if not. - bool find (void *object); - - /// Remove a registered cleanup hook object. Returns true if removed - /// false if not. - bool remove (void *object); - - /// Call all registered cleanup hooks, in reverse order of - /// registration. - void call_hooks (); - -private: - /** - * Keeps track of all registered objects. - */ - ACE_Cleanup_Info_Node_List registered_objects_; -}; - - -ACE_END_VERSIONED_NAMESPACE_DECL - -# if defined (ACE_HAS_INLINED_OSCALLS) -# if defined (ACE_INLINE) -# undef ACE_INLINE -# endif /* ACE_INLINE */ -# define ACE_INLINE inline -# include "ace/Cleanup.inl" -# endif /* ACE_HAS_INLINED_OSCALLS */ - -# include /**/ "ace/post.h" -#endif /* ACE_CLEANUP_H */ diff --git a/deps/acelite/ace/Cleanup.inl b/deps/acelite/ace/Cleanup.inl deleted file mode 100644 index fdae3412f..000000000 --- a/deps/acelite/ace/Cleanup.inl +++ /dev/null @@ -1,27 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Cleanup::ACE_Cleanup (void) -{ -} - -ACE_INLINE void* -ACE_Cleanup_Info_Node::object(void) -{ - return this->object_; -} - -ACE_INLINE ACE_CLEANUP_FUNC -ACE_Cleanup_Info_Node::cleanup_hook (void) -{ - return this->cleanup_hook_; -} - -ACE_INLINE void * -ACE_Cleanup_Info_Node::param (void) -{ - return this->param_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Cleanup_Strategies_T.cpp b/deps/acelite/ace/Cleanup_Strategies_T.cpp deleted file mode 100644 index 53cf0b876..000000000 --- a/deps/acelite/ace/Cleanup_Strategies_T.cpp +++ /dev/null @@ -1,93 +0,0 @@ -#ifndef ACE_CLEANUP_STRATEGIES_T_CPP -#define ACE_CLEANUP_STRATEGIES_T_CPP - -#include "ace/Cleanup_Strategies_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -//////////////////////////////////////////////////////////////////////////// - -template -ACE_Cleanup_Strategy::~ACE_Cleanup_Strategy (void) -{ -} - -template int -ACE_Cleanup_Strategy::cleanup (CONTAINER &container, - KEY *key, - VALUE *) -{ - return container.unbind (*key); -} - -//////////////////////////////////////////////////////////////////////////// - -template int -ACE_Recyclable_Handler_Cleanup_Strategy::cleanup ( - CONTAINER &container, - KEY *key, - VALUE *) -{ - VALUE value; - - if (container.unbind (*key, value) == -1) - return -1; - - value.first->recycler (0, 0); - - value.first->close (); - - return 0; -} - -///////////////////////////////////////////////////////////////////////////// - -template int -ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy::cleanup ( - CONTAINER &, - KEY *, - VALUE *value) -{ - return value->first ()->handle_close_i (); -} - -//////////////////////////////////////////////////////////////////////////// - -template int -ACE_Handler_Cleanup_Strategy::cleanup ( - CONTAINER &container, - KEY *key, - VALUE *value) -{ - // Remove the item from cache only if the handler isnt in use. - if ((*value)->active () == 0) - { - (*value)->close (); - - if (container.unbind (*key) == -1) - return -1; - - } - - return 0; -} - -//////////////////////////////////////////////////////////////////////////// - -template int -ACE_Null_Cleanup_Strategy::cleanup (CONTAINER &, - KEY *, - VALUE *) -{ - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_CLEANUP_STRATEGIES_T_CPP */ diff --git a/deps/acelite/ace/Cleanup_Strategies_T.h b/deps/acelite/ace/Cleanup_Strategies_T.h deleted file mode 100644 index c90dd5c5a..000000000 --- a/deps/acelite/ace/Cleanup_Strategies_T.h +++ /dev/null @@ -1,142 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Cleanup_Strategies_T.h - * - * @author Kirthika Parameswaran - */ -//============================================================================= - -#ifndef CLEANUP_STRATEGIES_H -#define CLEANUP_STRATEGIES_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -// For linkers that cant grok long names. -#define ACE_Cleanup_Strategy ACLE - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Cleanup_Strategy - * - * @brief Defines a default strategy to be followed for cleaning up - * entries from a map which is the container. - * - * By default the entry to be cleaned up is removed from the - * container. - */ -template -class ACE_Cleanup_Strategy -{ -public: - /// Destructor. - virtual ~ACE_Cleanup_Strategy (void); - - /// The method which will do the cleanup of the entry in the container. - virtual int cleanup (CONTAINER &container, KEY *key, VALUE *value); -}; - -////////////////////////////////////////////////////////////////////// -#define ACE_Recyclable_Handler_Cleanup_Strategy ARHCLE - -/** - * @class ACE_Recyclable_Handler_Cleanup_Strategy - * - * @brief Defines a strategy to be followed for cleaning up - * entries which are svc_handlers from a container. - * - * The entry to be cleaned up is removed from the container. - * Here, since we are dealing with svc_handlers specifically, we - * perform a couple of extra operations. @note To be used when - * the handler is recyclable. - */ -template -class ACE_Recyclable_Handler_Cleanup_Strategy : public ACE_Cleanup_Strategy -{ -public: - /// The method which will do the cleanup of the entry in the container. - virtual int cleanup (CONTAINER &container, KEY *key, VALUE *value); -}; - -////////////////////////////////////////////////////////////////////// -#define ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy ARRHCLE - -/** - * @class ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy - * - * @brief Defines a strategy to be followed for cleaning up - * entries which are svc_handlers from a container. - * - * The entry to be cleaned up is removed from the container. - * Here, since we are dealing with recyclable svc_handlers with - * addresses which are refcountable specifically, we perform a - * couple of extra operations and do so without any locking. - */ -template -class ACE_Refcounted_Recyclable_Handler_Cleanup_Strategy : public ACE_Cleanup_Strategy -{ -public: - /// The method which will do the cleanup of the entry in the container. - virtual int cleanup (CONTAINER &container, KEY *key, VALUE *value); -}; - -////////////////////////////////////////////////////////////////////// - -/** - * @class ACE_Handler_Cleanup_Strategy - * - * @brief Defines a strategy to be followed for cleaning up - * entries which are svc_handlers from a container. - * - * The entry to be cleaned up is removed from the container. - * Here, since we are dealing with svc_handlers specifically, we - * perform a couple of extra operations. @note This cleanup strategy - * should be used in the case when the handler has the caching - * attributes. - */ -template -class ACE_Handler_Cleanup_Strategy : public ACE_Cleanup_Strategy -{ -public: - /// The method which will do the cleanup of the entry in the container. - virtual int cleanup (CONTAINER &container, KEY *key, VALUE *value); -}; - -////////////////////////////////////////////////////////////////////// -#define ACE_Null_Cleanup_Strategy ANCLE - -/** - * @class ACE_Null_Cleanup_Strategy - * - * @brief Defines a do-nothing implementation of the cleanup strategy. - * - * This class simply does nothing at all! Can be used to nullify - * the effect of the Cleanup Strategy. - */ -template -class ACE_Null_Cleanup_Strategy : public ACE_Cleanup_Strategy -{ -public: - /// The dummy cleanup method. - virtual int cleanup (CONTAINER &container, KEY *key, VALUE *value); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Cleanup_Strategies_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Cleanup_Strategies_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* CLEANUP_STRATEGIES_H */ diff --git a/deps/acelite/ace/Codecs.cpp b/deps/acelite/ace/Codecs.cpp deleted file mode 100644 index 7b22f2735..000000000 --- a/deps/acelite/ace/Codecs.cpp +++ /dev/null @@ -1,247 +0,0 @@ -#include "ace/Codecs.h" -#include "ace/Log_Category.h" -#include "ace/OS_Memory.h" -#include "ace/OS_NS_ctype.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -namespace -{ - // Just in case ... -#undef alphabet -#undef pad -#undef max_columns - - // Symbols which form the Base64 alphabet (Defined as per RFC 2045) - ACE_Byte const alphabet[] = - "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; - - // The padding character used in the encoding - ACE_Byte const pad = '='; - - // Number of columns per line of encoded output (Can have a maximum - // value of 76). - int const max_columns = 72; -} - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -bool ACE_Base64::init_ = false; - -ACE_Byte ACE_Base64::decoder_[256]; - -ACE_Byte ACE_Base64::member_[256]; - -ACE_Byte* -ACE_Base64::encode (const ACE_Byte* input, - const size_t input_len, - size_t* output_len, - bool is_chunked) -{ - if (!ACE_Base64::init_) - ACE_Base64::init(); - - if (!input) - return 0; - - ACE_Byte* result = 0; - - size_t length = ((input_len + 2) / 3) * 4; - size_t num_lines = length / max_columns + 1; - length += num_lines + 1; -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (result, static_cast (ACE_Allocator::instance()->malloc(sizeof (ACE_Byte) * length)), 0); -#else - ACE_NEW_RETURN (result, ACE_Byte[length], 0); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - int char_count = 0; - int bits = 0; - size_t pos = 0; - int cols = 0; - - for (size_t i = 0; i < input_len; ++i) - { - bits += input[i]; - ++char_count; - - if (char_count == 3) - { - result[pos++] = alphabet[bits >> 18]; - result[pos++] = alphabet[(bits >> 12) & 0x3f]; - result[pos++] = alphabet[(bits >> 6) & 0x3f]; - result[pos++] = alphabet[bits & 0x3f]; - cols += 4; - if (cols == max_columns) { - if (is_chunked) - result[pos++] = '\n'; - cols = 0; - } - bits = 0; - char_count = 0; - } - else - { - bits <<= 8; - } - } - - if (char_count != 0) - { - bits <<= (16 - (8 * char_count)); - result[pos++] = alphabet[bits >> 18]; - result[pos++] = alphabet[(bits >> 12) & 0x3f]; - cols += 2; - if (char_count == 1) - { - result[pos++] = pad; - result[pos++] = pad; - cols += 2; - } - else - { - result[pos++] = alphabet[(bits >> 6) & 0x3f]; - result[pos++] = pad; - cols += 2; - } - } - - if (cols > 0 && is_chunked) - result[pos++] = '\n'; - - result[pos] = 0; - *output_len = pos; - return result; -} - -size_t -ACE_Base64::length (const ACE_Byte* input) -{ - if (!ACE_Base64::init_) - ACE_Base64::init(); - - ACE_Byte* ptr = const_cast (input); - while (*ptr != 0 && - (member_[*(ptr)] == 1 || *ptr == pad - || ACE_OS::ace_isspace (*ptr))) - ++ptr; - size_t len = ptr - input; - len = ((len + 3) / 4) * 3 + 1 ; - return len; -} - -ACE_Byte* -ACE_Base64::decode (const ACE_Byte* input, size_t* output_len) -{ - if (!ACE_Base64::init_) - ACE_Base64::init(); - - if (!input) - return 0; - - size_t result_len = ACE_Base64::length (input); - ACE_Byte* result = 0; - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (result, static_cast (ACE_Allocator::instance()->malloc(sizeof (ACE_Byte) * result_len)), 0); -#else - ACE_NEW_RETURN (result, ACE_Byte[result_len], 0); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - ACE_Byte* ptr = const_cast (input); - while (*ptr != 0 && - (member_[*(ptr)] == 1 || *ptr == pad - || ACE_OS::ace_isspace (*ptr))) - ++ptr; - size_t input_len = ptr - input; - - int char_count = 0; - int bits = 0; - size_t pos = 0; - - size_t i = 0; - for (; i < input_len; ++i) - { - if (input[i] == pad) - break; - if (!ACE_Base64::member_[input[i]]) - continue; - bits += decoder_[input[i]]; - ++char_count; - - if (char_count == 4) - { - result[pos++] = static_cast (bits >> 16); - result[pos++] = static_cast ((bits >> 8) & 0xff); - result[pos++] = static_cast (bits & 0xff); - bits = 0; - char_count = 0; - } - else - { - bits <<= 6; - } - } - - int errors = 0; - if ( i == input_len) - { - if (char_count) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("Decoding incomplete: atleast %d bits truncated\n"), - (4 - char_count) * 6)); - ++errors; - } - } - else - { - switch (char_count) - { - case 1: - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("Decoding incomplete: atleast 2 bits missing\n"))); - ++errors; - break; - case 2: - result[pos++] = static_cast (bits >> 10); - break; - case 3: - result[pos++] = static_cast (bits >> 16); - result[pos++] = static_cast ((bits >> 8) & 0xff); - break; - } - } - - if (errors) - { -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(result); -#else - delete[] result; -#endif /* ACE_HAS_ALLOC_HOOKS */ - return 0; - } - result[pos] = 0; - *output_len = pos; - return result; -} - -void -ACE_Base64::init () -{ - if (!ACE_Base64::init_) - { - for (ACE_Byte i = 0; i < sizeof (alphabet); ++i) - { - ACE_Base64::decoder_[alphabet[i]] = i; - ACE_Base64::member_ [alphabet[i]] = 1; - } - ACE_Base64::init_ = true; - } - return; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Codecs.h b/deps/acelite/ace/Codecs.h deleted file mode 100644 index 6440e7dad..000000000 --- a/deps/acelite/ace/Codecs.h +++ /dev/null @@ -1,110 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Codecs.h - * - * @author Krishnakumar B - * - * Codecs is a generic wrapper for various encoding and decoding - * mechanisms. Currently it includes Base64 content transfer-encoding as - * specified by RFC 2045, Multipurpose Internet Mail Extensions (MIME) Part - * One: Format of Internet Message Bodies. - */ -//============================================================================= - -#ifndef ACE_CODECS_H -#define ACE_CODECS_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Basic_Types.h" -#include "ace/Global_Macros.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Base64 - * - * @brief Encode/Decode a stream of bytes according to Base64 encoding. - * - * This class provides methods to encode or decode a stream of bytes - * to/from Base64 encoding. It doesn't convert the input stream to a - * canonical form before encoding. - */ -class ACE_Export ACE_Base64 -{ -public: - //@{ - - /** - * Encodes a stream of bytes to Base64 data - * - * @param input Binary data in byte stream. - * @param input_len Length of the byte stream. - * @param output_len Length of the encoded Base64 byte stream. - * @param is_chunked If true, terminate 72 character blocks with newline - * @return Encoded Base64 data in byte stream or NULL if input data cannot - * be encoded. - */ - static ACE_Byte* encode (const ACE_Byte* input, - const size_t input_len, - size_t* output_len, - bool is_chunked = true); - /** - * Decodes a stream of Base64 to bytes data - * - * @param input Encoded Base64 data in byte stream. - * @param output_len Length of the binary byte stream. - * @return Binary data in byte stream or NULL if input data cannot - * be encoded. - */ - static ACE_Byte* decode (const ACE_Byte* input, - size_t* output_len); - - /** - * Return the length of the encoded input data - * - * @param input Encoded Base64 data in byte stream. - * @return Length of the encoded Base64 data. - * - */ - static size_t length (const ACE_Byte* input); - - //@} - -protected: - // Prevent default construction. - ACE_Base64 (void) {} - -private: - // Preventing copying and assignment. - ACE_Base64 (ACE_Base64 const &); - ACE_Base64 & operator= (ACE_Base64 const &); - - /// Initialize the tables for encoding/decoding. - static void init (void); - -private: - /// Alphabet used for decoding i.e decoder_[alphabet_[i = 0..63]] = i - static ACE_Byte decoder_[]; - - /// Alphabet used to check valid range of encoded input i.e - /// member_[alphabet_[0..63]] = 1 - static ACE_Byte member_[]; - - /// Boolean to denote whether initialization is complete - static bool init_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#endif /* ACE_CODECS_H */ diff --git a/deps/acelite/ace/Codeset_IBM1047.cpp b/deps/acelite/ace/Codeset_IBM1047.cpp deleted file mode 100644 index edfd2bab4..000000000 --- a/deps/acelite/ace/Codeset_IBM1047.cpp +++ /dev/null @@ -1,374 +0,0 @@ - -//============================================================================= -/** - * @file Codeset_IBM1047.cpp - * - * Defines the arrays required to convert between ISO8859 (aka - * Latin/1) and IBM1047 (aka EBCDIC). - * - * @author Jim Rogers (jrogers@viasoft.com) - */ -//============================================================================= - - -#include "ace/Codeset_IBM1047.h" - -#if defined (ACE_HAS_EBCDIC) - -#include "ace/OS_Memory.h" -#include "ace/OS_NS_string.h" - -namespace -{ - char const to_IBM1047[] = - { - "\x00\x01\x02\x03\x37\x2D\x2E\x2F\x16\x05\x25\x0B\x0C\x0D\x0E\x0F" // 00-0F - "\x10\x11\x12\x13\x3C\x3D\x32\x26\x18\x19\x3F\x27\x22\x1D\x35\x1F" // 10-1F - "\x40\x5A\x7F\x7B\x5B\x6C\x50\x7D\x4D\x5D\x5C\x4E\x6B\x60\x4B\x61" // 20-2F - "\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\x7A\x5E\x4C\x7E\x6E\x6F" // 30-3F - "\x7C\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xD1\xD2\xD3\xD4\xD5\xD6" // 40-4F - "\xD7\xD8\xD9\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xAD\xE0\xBD\x5F\x6D" // 50-5F - "\x79\x81\x82\x83\x84\x85\x86\x87\x88\x89\x91\x92\x93\x94\x95\x96" // 60-6F - "\x97\x98\x99\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xC0\x4F\xD0\xA1\x07" // 70-7F - "\x43\x20\x21\x1C\x23\xEB\x24\x9B\x71\x28\x38\x49\x90\xBA\xEC\xDF" // 80-8F - "\x45\x29\x2A\x9D\x72\x2B\x8A\x9A\x67\x56\x64\x4A\x53\x68\x59\x46" // 90-9F - "\xEA\xDA\x2C\xDE\x8B\x55\x41\xFE\x58\x51\x52\x48\x69\xDB\x8E\x8D" // A0-AF - "\x73\x74\x75\xFA\x15\xB0\xB1\xB3\xB4\xB5\x6A\xB7\xB8\xB9\xCC\xBC" // B0-BF - "\xAB\x3E\x3B\x0A\xBF\x8F\x3A\x14\xA0\x17\xCB\xCA\x1A\x1B\x9C\x04" // C0-CF - "\x34\xEF\x1E\x06\x08\x09\x77\x70\xBE\xBB\xAC\x54\x63\x65\x66\x62" // D0-DF - "\x30\x42\x47\x57\xEE\x33\xB6\xE1\xCD\xED\x36\x44\xCE\xCF\x31\xAA" // E0-EF - "\xFC\x9E\xAE\x8C\xDD\xDC\x39\xFB\x80\xAF\xFD\x78\x76\xB2\x9F\xFF" // F0-FF -}; - - char const from_IBM1047[] = - { - "\x00\x01\x02\x03\xCF\x09\xD3\x7F\xD4\xD5\xC3\x0B\x0C\x0D\x0E\x0F" // 00-0F - "\x10\x11\x12\x13\xC7\xB4\x08\xC9\x18\x19\xCC\xCD\x83\x1D\xD2\x1F" // 10-1F - "\x81\x82\x1C\x84\x86\x0A\x17\x1B\x89\x91\x92\x95\xA2\x05\x06\x07" // 20-2F - "\x20\xEE\x16\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\x20\xC1\x1A" // 30-3F - "\x20\xA6\xE1\x80\xEB\x90\x9F\xE2\xAB\x8B\x9B\x2E\x3C\x28\x2B\x7C" // 40-4F - "\x26\xA9\xAA\x9C\xDB\xA5\x99\xE3\xA8\x9E\x21\x24\x2A\x29\x3B\x5E" // 50-5F - "\x2D\x2F\xDF\xDC\x9A\xDD\xDE\x98\x9D\xAC\xBA\x2C\x25\x5F\x3E\x3F" // 60-6F - "\xD7\x88\x94\xB0\xB1\xB2\xFC\xD6\xFB\x60\x3A\x23\x40\x27\x3D\x22" // 70-7F - "\xF8\x61\x62\x63\x64\x65\x66\x67\x68\x69\x96\xA4\xF3\xAF\xAE\xC5" // 80-8F - "\x8C\x6A\x6B\x6C\x6D\x6E\x6F\x70\x71\x72\x97\x87\xCE\x93\xF1\xFE" // 90-9F - "\xC8\x7E\x73\x74\x75\x76\x77\x78\x79\x7A\xEF\xC0\xDA\x5B\xF2\xF9" // A0-AF - "\xB5\xB6\xFD\xB7\xB8\xB9\xE6\xBB\xBC\xBD\x8D\xD9\xBF\x5D\xD8\xC4" // B0-BF - "\x7B\x41\x42\x43\x44\x45\x46\x47\x48\x49\xCB\xCA\xBE\xE8\xEC\xED" // C0-CF - "\x7D\x4A\x4B\x4C\x4D\x4E\x4F\x50\x51\x52\xA1\xAD\xF5\xF4\xA3\x8F" // D0-DF - "\x5C\xE7\x53\x54\x55\x56\x57\x58\x59\x5A\xA0\x85\x8E\xE9\xE4\xD1" // E0-EF - "\x30\x31\x32\x33\x34\x35\x36\x37\x38\x39\xB3\xF7\xF0\xFA\xA7\xFF" // F0-FF - }; -} - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_IBM1047_ISO8859::ACE_IBM1047_ISO8859 (void) -{ -} - -ACE_IBM1047_ISO8859::~ACE_IBM1047_ISO8859 (void) -{ -} - -ACE_CDR::ULong -ACE_IBM1047_ISO8859::ncs () -{ - return 0x10020417; -} - -ACE_CDR::ULong -ACE_IBM1047_ISO8859::tcs () -{ - return 0x00010001; -} - -ACE_CDR::Boolean -ACE_IBM1047_ISO8859::read_char (ACE_InputCDR &in, - ACE_CDR::Char &x) -{ - if (this->read_1 (in, reinterpret_cast (&x))) - { - x = to_IBM1047[x]; - return 1; - } - return 0; -} - -ACE_CDR::Boolean -ACE_IBM1047_ISO8859::read_string (ACE_InputCDR& in, - ACE_CDR::Char *& x) -{ - ACE_CDR::ULong len; - - in.read_ulong (len); - - if (len > 0) - { - ACE_NEW_RETURN (x, - ACE_CDR::Char[len], - 0); - - if (this->read_char_array (in, x, len)) - return 1; - - delete [] x; - } - - x = 0; - return 0; -} - -ACE_CDR::Boolean -ACE_IBM1047_ISO8859::read_string (ACE_InputCDR& in, - std::string & x) -{ -#if defined (ACE_HAS_CPP11) - ACE_CDR::ULong len; - - in.read_ulong (len); - - if (len > 0) - { - try - { - x.resize (len); - } - catch (const std::bad_alloc&) - { - return false; - } - - if (this->read_char_array (in, &x[0], len)) - { - x.resize (len-1); // drop terminating '\0' read from stream - return true; - } - - delete [] x; - } - - x.clear (); - return false; -#else - return this->ACE_Char_Codeset_Translator::read_string (in, x); -#endif -} - -ACE_CDR::Boolean -ACE_IBM1047_ISO8859::read_char_array (ACE_InputCDR& in, - ACE_CDR::Char* x, - ACE_CDR::ULong len) -{ - if (this->read_array (in, - x, - ACE_CDR::OCTET_SIZE, - ACE_CDR::OCTET_ALIGN, - len)) - { - for (ACE_CDR::ULong i = 0; i != len; ++i) - x[i] = to_IBM1047[x[i]]; - - return 1; - } - - return 0; -} - -ACE_CDR::Boolean -ACE_IBM1047_ISO8859::write_char (ACE_OutputCDR& out, - ACE_CDR::Char x) -{ - return - this->write_1 (out, - reinterpret_cast (&from_IBM1047[x])); -} - -ACE_CDR::Boolean -ACE_IBM1047_ISO8859::write_string (ACE_OutputCDR& out, - ACE_CDR::ULong len, - const ACE_CDR::Char* x) -{ - if (out.write_ulong (len + 1)) - return this->write_char_array (out, x, len + 1); - return 0; -} - -ACE_CDR::Boolean -ACE_IBM1047_ISO8859::write_char_array (ACE_OutputCDR& out, - const ACE_CDR::Char* x, - ACE_CDR::ULong len) -{ - char *buf = 0; - if (this->adjust (out, len, 1, buf) == 0) - { - ACE_OS::memcpy (buf, x, len); - - for (ACE_CDR::ULong i = 0; i != len; ++i) - buf[i] = from_IBM1047[buf[i]]; - - return 1; - } - - this->good_bit(out, 0); - return 0; -} - -// **************************************************************** - -ACE_ISO8859_IBM1047::ACE_ISO8859_IBM1047 (void) -{ -} - -ACE_ISO8859_IBM1047::~ACE_ISO8859_IBM1047 (void) -{ -} - -ACE_CDR::ULong -ACE_ISO8859_IBM1047::ncs () -{ - return 0x00010001; -} - -ACE_CDR::ULong -ACE_ISO8859_IBM1047::tcs () -{ - return 0x10020417; -} - -ACE_CDR::Boolean -ACE_ISO8859_IBM1047::read_char (ACE_InputCDR& in, - ACE_CDR::Char& x) -{ - if (this->read_1 (in, reinterpret_cast (&x))) - { - x = from_IBM1047[x]; - return 1; - } - return 0; -} - -ACE_CDR::Boolean -ACE_ISO8859_IBM1047::read_string (ACE_InputCDR &in, - ACE_CDR::Char *&x) -{ - ACE_CDR::ULong len; - - in.read_ulong (len); - - if (len > 0) - { - ACE_NEW_RETURN (x, - ACE_CDR::Char[len], - 0); - - if (this->read_char_array (in, x, len)) - return 1; - - delete [] x; - } - - x = 0; - return 0; -} - -ACE_CDR::Boolean -ACE_ISO8859_IBM1047::read_string (ACE_InputCDR& in, - std::string & x) -{ -#if defined (ACE_HAS_CPP11) - ACE_CDR::ULong len; - - in.read_ulong (len); - - if (len > 0) - { - try - { - x.resize (len); - } - catch (const std::bad_alloc&) - { - return false; - } - - if (this->read_char_array (in, &x[0], len)) - { - x.resize (len-1); // drop terminating '\0' read from stream - return true; - } - - delete [] x; - } - - x.clear (); - return false; -#else - return this->ACE_Char_Codeset_Translator::read_string (in, x); -#endif -} - -ACE_CDR::Boolean -ACE_ISO8859_IBM1047::read_char_array (ACE_InputCDR &in, - ACE_CDR::Char *x, - ACE_CDR::ULong len) -{ - if (this->read_array (in, - x, - ACE_CDR::OCTET_SIZE, - ACE_CDR::OCTET_ALIGN, - len)) - { - for (ACE_CDR::ULong i = 0; i != len; ++i) - x[i] = from_IBM1047[x[i]]; - - return 1; - } - - return 0; -} - -ACE_CDR::Boolean -ACE_ISO8859_IBM1047::write_char (ACE_OutputCDR &out, - ACE_CDR::Char x) -{ - return - this->write_1 (out, - reinterpret_cast (&to_IBM1047[x])); -} - -ACE_CDR::Boolean -ACE_ISO8859_IBM1047::write_string (ACE_OutputCDR& out, - ACE_CDR::ULong len, - const ACE_CDR::Char* x) -{ - if (out.write_ulong (len + 1)) - return this->write_char_array (out, x, len + 1); - else - return 0; -} - -ACE_CDR::Boolean -ACE_ISO8859_IBM1047::write_char_array (ACE_OutputCDR &out, - const ACE_CDR::Char *x, - ACE_CDR::ULong len) -{ - char *buf = 0; - - if (this->adjust (out, len, 1, buf) == 0) - { - ACE_OS::memcpy (buf, x, len); - - for (ACE_CDR::ULong i = 0; i != len; ++i) - buf[i] = to_IBM1047[buf[i]]; - - return 1; - } - - this->good_bit (out, 0); - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_EBCDIC */ diff --git a/deps/acelite/ace/Codeset_IBM1047.h b/deps/acelite/ace/Codeset_IBM1047.h deleted file mode 100644 index d9d84aa40..000000000 --- a/deps/acelite/ace/Codeset_IBM1047.h +++ /dev/null @@ -1,129 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Codeset_IBM1047.h - * - * Declares the arrays required to convert between ISO8859 (aka - * Latin/1) and IBM1047 (aka EBCDIC). - * - * @author Jim Rogers (jrogers@viasoft.com) - */ -//============================================================================= - - -#ifndef ACE_CODESET_IMB1047_H -#define ACE_CODESET_IMB1047_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_EBCDIC) - -#include "ace/CDR_Stream.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// **************************************************************** - -/** - * @class ACE_IBM1047_ISO8859 - * - * @brief Codeset translation specialization. - * - * This class performs the codeset translation: - * - Native: IBM_1047 (i.e. EBCDIC) - * - Stream: ISO-8859 (i.e. Latin/1) - */ -class ACE_Export ACE_IBM1047_ISO8859 : public ACE_Char_Codeset_Translator -{ -public: - /// A do nothing constructor. - ACE_IBM1047_ISO8859 (void); - - /// Virtual destruction - virtual ~ACE_IBM1047_ISO8859 (void); - - // = Documented in $ACE_ROOT/ace/CDR_Stream.h - virtual ACE_CDR::Boolean read_char (ACE_InputCDR &, - ACE_CDR::Char &); - virtual ACE_CDR::Boolean read_string (ACE_InputCDR &, - ACE_CDR::Char *&); - virtual ACE_CDR::Boolean read_string (ACE_InputCDR &, - std::string &); - virtual ACE_CDR::Boolean read_char_array (ACE_InputCDR &, - ACE_CDR::Char *, - ACE_CDR::ULong); - virtual ACE_CDR::Boolean write_char (ACE_OutputCDR &, - ACE_CDR::Char); - virtual ACE_CDR::Boolean write_string (ACE_OutputCDR &, - ACE_CDR::ULong, - const ACE_CDR::Char *); - virtual ACE_CDR::Boolean write_char_array (ACE_OutputCDR &, - const ACE_CDR::Char *, - ACE_CDR::ULong); - - /// Return the native codeset ID as defined in the OSF code and character - /// set registry, 0x10020417 - virtual ACE_CDR::ULong ncs (); - /// Return the translated codeset ID as defined in the OSF code and character - /// set registry, 0x00010001 - virtual ACE_CDR::ULong tcs (); -}; - -/** - * @class ACE_ISO8859_IBM1047 - * - * @brief Codeset translation specialization. - * - * This class performs the codeset translation: - * - Native: ISO-8859 (i.e. Latin/1) - * - Stream: IBM-1047 (i.e. EBCDIC) - */ -class ACE_Export ACE_ISO8859_IBM1047 : public ACE_Char_Codeset_Translator -{ -public: - /// A do nothing constructor. - ACE_ISO8859_IBM1047 (void); - - /// Virtual destruction - virtual ~ACE_ISO8859_IBM1047 (void); - - // = Documented in $ACE_ROOT/ace/CDR_Stream.h - virtual ACE_CDR::Boolean read_char (ACE_InputCDR &, - ACE_CDR::Char &); - virtual ACE_CDR::Boolean read_string (ACE_InputCDR &, - ACE_CDR::Char *&); - virtual ACE_CDR::Boolean read_string (ACE_InputCDR &, - std::string &); - virtual ACE_CDR::Boolean read_char_array (ACE_InputCDR &, - ACE_CDR::Char *, - ACE_CDR::ULong); - virtual ACE_CDR::Boolean write_char (ACE_OutputCDR &, - ACE_CDR::Char); - virtual ACE_CDR::Boolean write_string (ACE_OutputCDR &, - ACE_CDR::ULong, - const ACE_CDR::Char *); - virtual ACE_CDR::Boolean write_char_array (ACE_OutputCDR &, - const ACE_CDR::Char *, - ACE_CDR::ULong); - - /// Return the native codeset ID as defined in the OSF code and character - /// set registry, 0x00010001 - virtual ACE_CDR::ULong ncs (); - /// Return the translated codeset ID as defined in the OSF code and character - /// set registry, 0x10020417 - virtual ACE_CDR::ULong tcs (); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_EBCDIC */ - -#include /**/ "ace/post.h" - -#endif /* ACE_CODESET_IMB1047_H */ diff --git a/deps/acelite/ace/Codeset_Registry.cpp b/deps/acelite/ace/Codeset_Registry.cpp deleted file mode 100644 index 7ae55118d..000000000 --- a/deps/acelite/ace/Codeset_Registry.cpp +++ /dev/null @@ -1,110 +0,0 @@ -//============================================================================= -/** - * @file Codeset_Registry.cpp - * - * emulated codset regstry functions - * - * @author Phil Mesnier - */ -//============================================================================= - -#include "ace/Codeset_Registry.h" -#include "ace/OS_Memory.h" -#include "ace/OS_NS_string.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Codeset_Registry.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -int -ACE_Codeset_Registry::locale_to_registry_i (const ACE_CString &locale, - ACE_CDR::ULong &codeset_id, - ACE_CDR::UShort *num_sets, - ACE_CDR::UShort **char_sets) -{ - registry_entry const *element = 0; - for (size_t i = 0; element == 0 && i < num_registry_entries_; i++) - if (ACE_OS::strcmp (registry_db_[i].loc_name_, locale.c_str ()) == 0) - element = ®istry_db_[i]; - if (element == 0) - return 0; - codeset_id = element->codeset_id_; - if (num_sets != 0) - *num_sets = element->num_sets_; - if (char_sets != 0) - { -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (*char_sets,static_cast (ACE_Allocator::instance()->malloc(sizeof (ACE_CDR::UShort) * (element->num_sets_))),0); -#else - ACE_NEW_RETURN (*char_sets,ACE_CDR::UShort[element->num_sets_],0); -#endif /* ACE_HAS_ALLOC_HOOKS */ - ACE_OS::memcpy (*char_sets, element->char_sets_, - element->num_sets_ * sizeof (ACE_CDR::UShort)); - } - return 1; -} - -int -ACE_Codeset_Registry::registry_to_locale_i (ACE_CDR::ULong codeset_id, - ACE_CString &locale, - ACE_CDR::UShort *num_sets, - ACE_CDR::UShort **char_sets) -{ - registry_entry const *element = 0; - for (size_t i = 0; element == 0 && i < num_registry_entries_; i++) - if (codeset_id == registry_db_[i].codeset_id_) - element = ®istry_db_[i]; - if (element == 0) - return 0; - locale.set (element->loc_name_); - if (num_sets != 0) - *num_sets = element->num_sets_; - if (char_sets != 0) - { -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (*char_sets,static_cast (ACE_Allocator::instance()->malloc(sizeof (ACE_CDR::UShort) * (element->num_sets_))),0); -#else - ACE_NEW_RETURN (*char_sets,ACE_CDR::UShort[element->num_sets_],0); -#endif /* ACE_HAS_ALLOC_HOOKS */ - ACE_OS::memcpy (*char_sets, element->char_sets_, - element->num_sets_ * sizeof (ACE_CDR::UShort)); - } - return 1; -} - -int -ACE_Codeset_Registry::is_compatible_i (ACE_CDR::ULong codeset_id, - ACE_CDR::ULong other) -{ - registry_entry const *lhs = 0; - registry_entry const *rhs = 0; - for (size_t i = 0; (lhs == 0 || rhs == 0) && i < num_registry_entries_; i++) - { - if (codeset_id == registry_db_[i].codeset_id_) - lhs = ®istry_db_[i]; - if (other == registry_db_[i].codeset_id_) - rhs = ®istry_db_[i]; - } - - if (lhs == 0 || rhs == 0) - return 0; - - for (ACE_CDR::UShort l = 0; l < lhs->num_sets_; l++) - for (ACE_CDR::UShort r = 0; r < rhs->num_sets_; r++) - if (rhs->char_sets_[r] == lhs->char_sets_[l]) - return 1; - return 0; -} - -ACE_CDR::Short -ACE_Codeset_Registry::get_max_bytes_i (ACE_CDR::ULong codeset_id) -{ - for (size_t i = 0; i < num_registry_entries_; i++) - if (codeset_id == registry_db_[i].codeset_id_) - return registry_db_[i].max_bytes_; - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Codeset_Registry.h b/deps/acelite/ace/Codeset_Registry.h deleted file mode 100644 index 8fc9944c8..000000000 --- a/deps/acelite/ace/Codeset_Registry.h +++ /dev/null @@ -1,97 +0,0 @@ -// -*- C++ -*- -//============================================================================= -/** - * @file Codeset_Registry.h - * - * ACE wrapper around access functions for the OSF's DCE codeset registry - * access functions - * - * For environments that intrinsicly support the DCE defined access functions, - * the methods in this class are simply wrappers. On other platforms, emulation - * is provided. The motivation for this class is to support interoperability - * via translators and the CDR streams, primarily in TAO, but this capability - * is not restricted to CORBA. - * - * The emulated functionality supports Open Group RFC #40, currently RFC 40.2, - * www.opengroup.org/tech/rfc/rfc40.2.html - * - * @author Phil Mesnier - */ -//============================================================================= - -#ifndef ACE_CODESET_REGISTRY_H -#define ACE_CODESET_REGISTRY_H - -#include /**/ "ace/pre.h" -#include "ace/SString.h" -#include "ace/CDR_Base.h" -#include "ace/Codeset_Symbols.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Export ACE_Codeset_Registry -{ -public: - /// Based on a locale string, find the registry value and optional codeset - /// collection. This wraps the dce_cs_loc_to_rgy function, or emulates it. - static int locale_to_registry (const ACE_CString &locale, - ACE_CDR::ULong &codeset_id, - ACE_CDR::UShort * = 0, - ACE_CDR::UShort ** = 0); - - /// Based on a registry value, find the locale string and optional codeset - /// collection. This wraps the dce_cs_rgy_to_loc function, or emulates it. - static int registry_to_locale (ACE_CDR::ULong codeset_id, - ACE_CString &locale, - ACE_CDR::UShort * = 0, - ACE_CDR::UShort ** = 0); - - /// Tell if two codesets are compatible. This wraps the - /// rpc_cs_char_set_compat_check function. - static int is_compatible (ACE_CDR::ULong codeset_id, - ACE_CDR::ULong other); - - /// Return the max number of bytes required to represent a single character. - /// This wraps the rpc_rgy_get_max_bytes function. - static ACE_CDR::Short get_max_bytes (ACE_CDR::ULong codeset_id); - - enum {max_charsets_ = 5}; -protected: - typedef struct { - const char * desc_; - const char * loc_name_; - ACE_CDR::ULong codeset_id_; - ACE_CDR::UShort num_sets_; - ACE_CDR::UShort char_sets_[max_charsets_]; - ACE_CDR::UShort max_bytes_; - } registry_entry; - -private: - static size_t const num_registry_entries_; - static registry_entry const registry_db_[]; - - static int locale_to_registry_i (const ACE_CString &locale, - ACE_CDR::ULong &codeset_id, - ACE_CDR::UShort * = 0, - ACE_CDR::UShort ** = 0); - static int registry_to_locale_i (ACE_CDR::ULong codeset_id, - ACE_CString &locale, - ACE_CDR::UShort * = 0, - ACE_CDR::UShort ** = 0); - static int is_compatible_i (ACE_CDR::ULong codeset_id, - ACE_CDR::ULong other); - static ACE_CDR::Short get_max_bytes_i (ACE_CDR::ULong codeset_id); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Codeset_Registry.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_CODESET_REGISTRY_H */ diff --git a/deps/acelite/ace/Codeset_Registry.inl b/deps/acelite/ace/Codeset_Registry.inl deleted file mode 100644 index f459d4d83..000000000 --- a/deps/acelite/ace/Codeset_Registry.inl +++ /dev/null @@ -1,63 +0,0 @@ -// -*- C++ -*- -//============================================================================= -/** - * @file Codeset_Registry.inl - * - * ACE wrapper around access functions for the OSF's DCE codeset registry - * access functions - the inline functions either call the system supplied - * DCE based codeset regsitry function, or calls the emulation - * - * @author Phil Mesnier - */ -//============================================================================= - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -int -ACE_Codeset_Registry::locale_to_registry(const ACE_CString &locale, - ACE_CDR::ULong &codeset_id, - ACE_CDR::UShort *num_sets, - ACE_CDR::UShort **char_sets) -{ - return ACE_Codeset_Registry::locale_to_registry_i (locale, - codeset_id, - num_sets, - char_sets); -} - -// based on a registry value, find the locale string and optional codeset -// collection. This wraps the dce_cs_rgy_to_loc function, or emulates it. -ACE_INLINE -int -ACE_Codeset_Registry::registry_to_locale(ACE_CDR::ULong codeset_id, - ACE_CString &locale, - ACE_CDR::UShort *num_sets, - ACE_CDR::UShort **char_sets) -{ - return ACE_Codeset_Registry::registry_to_locale_i (codeset_id, - locale, - num_sets, - char_sets); -} - -// Tell if two codesets are compatible. This wraps the -// rpc_cs_char_set_compat_check function. -ACE_INLINE -int -ACE_Codeset_Registry::is_compatible (ACE_CDR::ULong codeset_id, - ACE_CDR::ULong other) -{ - return ACE_Codeset_Registry::is_compatible_i (codeset_id,other); -} - -// Return the max number of bytes required to represent a single character. -// This wraps the rpc_rgy_get_max_bytes function. -ACE_INLINE -ACE_CDR::Short -ACE_Codeset_Registry::get_max_bytes (ACE_CDR::ULong codeset_id) -{ - return ACE_Codeset_Registry::get_max_bytes_i (codeset_id); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Codeset_Registry_db.cpp b/deps/acelite/ace/Codeset_Registry_db.cpp deleted file mode 100644 index 53b719d87..000000000 --- a/deps/acelite/ace/Codeset_Registry_db.cpp +++ /dev/null @@ -1,33 +0,0 @@ -/* - * Codeset registry DB, generated Fri Feb 28 21:01:30 2003 - * source: code_set_registry1.2g.txt - * - * To populate the registry_db, construct a codeset registry text file based - * on the OSF's Character and Code Set Registry. See DCE RFC 40.1 for details - * on obtaining the full text for the current registry. Once you have composed - * a text file containing all the desired codeset information, build and run - * mkcsregdb. The source is in $ACE_ROOT/apps/mkcsregdb. It will generate a new - * copy of this file, with the registry_db_ array properly initialized. - */ - -#include "ace/Codeset_Registry.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Codeset_Registry::registry_entry const -ACE_Codeset_Registry::registry_db_[] = -{ - {"ISO/IEC 10646-1:1993; UCS-2, Level 1","UCS-2",0x00010100,1,{0x1000},2}, - {"ISO 8859-1:1987; Latin Alphabet No. 1","ISO8859_1",0x00010001,1,{0x0011},1}, - {"IBM-1047 (CCSID 01047); Latin-1 Open System","EBCDIC",0x10020417,1,{0x0011},1}, - {"ISO/IEC 10646-1:1993; UCS-4, Level 1","UCS-4",0x00010104,1,{0x1000},4}, - {"ISO/IEC 10646-1:1993; UTF-16, UCS Transformation Format 16-bit form","UTF-16",0x00010109,1,{0x1000},2}, - {"X/Open UTF-8; UCS Transformation Format 8 (UTF-8)","UTF-8",0x05010001,1,{0x1000},6}, - {"ISO/IEC 8859-5:1988; Latin-Cyrillic Alphabet","ISO-8859-5",0x00010005,1,{0x0015},1}, - {"IBM-1251 (CCSID 01251); MS Windows Cyrillic","CP1251",0x100204e3,1,{0x0015},1}, - {"IBM-855 (CCSID 04951); Cyrillic Personal Computer","CP855",0x10021357,1,{0x0015},1} -}; - -size_t const ACE_Codeset_Registry::num_registry_entries_ = 9; - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Codeset_Symbols.h b/deps/acelite/ace/Codeset_Symbols.h deleted file mode 100644 index f57935f8c..000000000 --- a/deps/acelite/ace/Codeset_Symbols.h +++ /dev/null @@ -1,218 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Codeset_Symbols.h - * - * Symbolic names for codeset ids. - * - * @author Dale Wilson (wilson_d@ociweb.com) - */ -//============================================================================= -#ifndef CODESET_SYMBOLS_H -#define CODESET_SYMBOLS_H - -// These numbers are assigned by the OpenGroup, a database is -// available at -// -// ftp://ftp.opengroup.org/pub/code_set_registry/ -// -// Alas, the database is in a semi-regular text file -- difficult to use. -// The following C/C++-friendly version of the codeset ids was captured -// from Version 1.2g of the registry. -// -#define ACE_CODESET_ID_ISO_8859_1 0x00010001U -#define ACE_CODESET_ID_ISO_8859_2 0x00010002U -#define ACE_CODESET_ID_ISO_8859_3 0x00010003U -#define ACE_CODESET_ID_ISO_8859_4 0x00010004U -#define ACE_CODESET_ID_ISO_8859_5 0x00010005U -#define ACE_CODESET_ID_ISO_8859_6 0x00010006U -#define ACE_CODESET_ID_ISO_8859_7 0x00010007U -#define ACE_CODESET_ID_ISO_8859_8 0x00010008U -#define ACE_CODESET_ID_ISO_8859_9 0x00010009U -#define ACE_CODESET_ID_ISO_8859_10 0x0001000AU -#define ACE_CODESET_ID_ISO_8859_15 0x0001000FU -#define ACE_CODESET_ID_ISO_646 0x00010020U -#define ACE_CODESET_ID_ISO_UCS_2_LEVEL_1 0x00010100U -#define ACE_CODESET_ID_ISO_UCS_2_LEVEL_2 0x00010101U -#define ACE_CODESET_ID_ISO_UCS_2_LEVEL_3 0x00010102U -#define ACE_CODESET_ID_ISO_UCS_4_LEVEL_1 0x00010104U -#define ACE_CODESET_ID_ISO_UCS_4_LEVEL_2 0x00010105U -#define ACE_CODESET_ID_ISO_UCS_4_LEVEL_3 0x00010106U -#define ACE_CODESET_ID_ISO_UTF_8 0x00010108U -#define ACE_CODESET_ID_ISO_UTF_16 0x00010109U -#define ACE_CODESET_ID_JIS_X0201 0x00030001U -#define ACE_CODESET_ID_JIS_X0208_1978 0x00030004U -#define ACE_CODESET_ID_JIS_X0208_1983 0x00030005U -#define ACE_CODESET_ID_JIS_X0208_1990 0x00030006U -#define ACE_CODESET_ID_JIS_X0212 0x0003000AU -#define ACE_CODESET_ID_JIS_EUCJP 0x00030010U -#define ACE_CODESET_ID_KS_C5601 0x00040001U -#define ACE_CODESET_ID_KS_C5657 0x00040002U -#define ACE_CODESET_ID_KS_EUCKR 0x0004000AU -#define ACE_CODESET_ID_CNS_11643_1986 0x00050001U -#define ACE_CODESET_ID_CNS_11643_1992 0x00050002U -#define ACE_CODESET_ID_CNS_EUCTW_1991 0x0005000AU -#define ACE_CODESET_ID_CNS_EUCTW_1993 0x00050010U -#define ACE_CODESET_ID_TIS_620_25290X000B0001U -#define ACE_CODESET_ID_TTB_CCDC 0x000D0001U -#define ACE_CODESET_ID_OSF_JAPANESE_UJIS 0x05000010U -#define ACE_CODESET_ID_OSF_JAPANESE_SJIS_1 0x05000011U -#define ACE_CODESET_ID_OSF_JAPANESE_SJIS_2 0x05000012U -#define ACE_CODESET_ID_XOPEN_UTF_8 0x05010001U -#define ACE_CODESET_ID_JVC_EUCJP 0x05020001U -#define ACE_CODESET_ID_JVC_SJIS 0x05020002U -#define ACE_CODESET_ID_DEC_KANJI 0x10000001U -#define ACE_CODESET_ID_SUPER_DEC_KANJI 0x10000002U -#define ACE_CODESET_ID_DEC_SHIFT_JIS 0x10000003U -#define ACE_CODESET_ID_HP_ROMAN8 0x10010001U -#define ACE_CODESET_ID_HP_KANA8 0x10010002U -#define ACE_CODESET_ID_HP_ARABIC8 0x10010003U -#define ACE_CODESET_ID_HP_GREEK8 0x10010004U -#define ACE_CODESET_ID_HP_HEBREW8 0x10010005U -#define ACE_CODESET_ID_HP_TURKISH8 0x10010006U -#define ACE_CODESET_ID_HP15CN 0x10010007U -#define ACE_CODESET_ID_HP_BIG5 0x10010008U -#define ACE_CODESET_ID_HP_JAPANESE15__SJIS_ 0x10010009U -#define ACE_CODESET_ID_HP_SJISHI 0x1001000AU -#define ACE_CODESET_ID_HP_SJISPC 0x1001000BU -#define ACE_CODESET_ID_HP_UJIS 0x1001000CU -#define ACE_CODESET_ID_IBM_037 0x10020025U -#define ACE_CODESET_ID_IBM_273 0x10020111U -#define ACE_CODESET_ID_IBM_277 0x10020115U -#define ACE_CODESET_ID_IBM_278 0x10020116U -#define ACE_CODESET_ID_IBM_280 0x10020118U -#define ACE_CODESET_ID_IBM_282 0x1002011AU -#define ACE_CODESET_ID_IBM_284 0x1002011CU -#define ACE_CODESET_ID_IBM_285 0x1002011DU -#define ACE_CODESET_ID_IBM_290 0x10020122U -#define ACE_CODESET_ID_IBM_297 0x10020129U -#define ACE_CODESET_ID_IBM_300 0x1002012CU -#define ACE_CODESET_ID_IBM_301 0x1002012DU -#define ACE_CODESET_ID_IBM_420 0x100201A4U -#define ACE_CODESET_ID_IBM_424 0x100201A8U -#define ACE_CODESET_ID_IBM_437 0x100201B5U -#define ACE_CODESET_ID_IBM_500 0x100201F4U -#define ACE_CODESET_ID_IBM_833 0x10020341U -#define ACE_CODESET_ID_IBM_834 0x10020342U -#define ACE_CODESET_ID_IBM_835 0x10020343U -#define ACE_CODESET_ID_IBM_836 0x10020344U -#define ACE_CODESET_ID_IBM_837 0x10020345U -#define ACE_CODESET_ID_IBM_838 0x10020346U -#define ACE_CODESET_ID_IBM_839 0x10020347U -#define ACE_CODESET_ID_IBM_850 0x10020352U -#define ACE_CODESET_ID_IBM_852 0x10020354U -#define ACE_CODESET_ID_IBM_855 0x10020357U -#define ACE_CODESET_ID_IBM_856 0x10020358U -#define ACE_CODESET_ID_IBM_857 0x10020359U -#define ACE_CODESET_ID_IBM_861 0x1002035DU -#define ACE_CODESET_ID_IBM_862 0x1002035EU -#define ACE_CODESET_ID_IBM_863 0x1002035FU -#define ACE_CODESET_ID_IBM_864 0x10020360U -#define ACE_CODESET_ID_IBM_866 0x10020362U -#define ACE_CODESET_ID_IBM_868 0x10020364U -#define ACE_CODESET_ID_IBM_869 0x10020365U -#define ACE_CODESET_ID_IBM_870 0x10020366U -#define ACE_CODESET_ID_IBM_871 0x10020367U -#define ACE_CODESET_ID_IBM_874 0x1002036AU -#define ACE_CODESET_ID_IBM_875 0x1002036BU -#define ACE_CODESET_ID_IBM_880 0x10020370U -#define ACE_CODESET_ID_IBM_891 0x1002037BU -#define ACE_CODESET_ID_IBM_896 0x10020380U -#define ACE_CODESET_ID_IBM_897 0x10020381U -#define ACE_CODESET_ID_IBM_903 0x10020387U -#define ACE_CODESET_ID_IBM_904 0x10020388U -#define ACE_CODESET_ID_IBM_918 0x10020396U -#define ACE_CODESET_ID_IBM_921 0x10020399U -#define ACE_CODESET_ID_IBM_922 0x1002039AU -#define ACE_CODESET_ID_IBM_926 0x1002039EU -#define ACE_CODESET_ID_IBM_927 0x1002039FU -#define ACE_CODESET_ID_IBM_928 0x100203A0U -#define ACE_CODESET_ID_IBM_929 0x100203A1U -#define ACE_CODESET_ID_IBM_930 0x100203A2U -#define ACE_CODESET_ID_IBM_932 0x100203A4U -#define ACE_CODESET_ID_IBM_933 0x100203A5U -#define ACE_CODESET_ID_IBM_934 0x100203A6U -#define ACE_CODESET_ID_IBM_935 0x100203A7U -#define ACE_CODESET_ID_IBM_936 0x100203A8U -#define ACE_CODESET_ID_IBM_937 0x100203A9U -#define ACE_CODESET_ID_IBM_938 0x100203AAU -#define ACE_CODESET_ID_IBM_939 0x100203ABU -#define ACE_CODESET_ID_IBM_941 0x100203ADU -#define ACE_CODESET_ID_IBM_942 0x100203AEU -#define ACE_CODESET_ID_IBM_943 0x100203AFU -#define ACE_CODESET_ID_IBM_946 0x100203B2U -#define ACE_CODESET_ID_IBM_947 0x100203B3U -#define ACE_CODESET_ID_IBM_948 0x100203B4U -#define ACE_CODESET_ID_IBM_949 0x100203B5U -#define ACE_CODESET_ID_IBM_950 0x100203B6U -#define ACE_CODESET_ID_IBM_951 0x100203B7U -#define ACE_CODESET_ID_IBM_955 0x100203BBU -#define ACE_CODESET_ID_IBM_964 0x100203C4U -#define ACE_CODESET_ID_IBM_970 0x100203CAU -#define ACE_CODESET_ID_IBM_1006 0x100203EEU -#define ACE_CODESET_ID_IBM_1025 0x10020401U -#define ACE_CODESET_ID_IBM_1026 0x10020402U -#define ACE_CODESET_ID_IBM_1027 0x10020403U -#define ACE_CODESET_ID_IBM_1040 0x10020410U -#define ACE_CODESET_ID_IBM_1041 0x10020411U -#define ACE_CODESET_ID_IBM_1043 0x10020413U -#define ACE_CODESET_ID_IBM_1046 0x10020416U -#define ACE_CODESET_ID_IBM_1047 0x10020417U -#define ACE_CODESET_ID_IBM_1088 0x10020440U -#define ACE_CODESET_ID_IBM_1097 0x10020449U -#define ACE_CODESET_ID_IBM_1098 0x1002044AU -#define ACE_CODESET_ID_IBM_1112 0x10020458U -#define ACE_CODESET_ID_IBM_1114 0x1002045AU -#define ACE_CODESET_ID_IBM_1115 0x1002045BU -#define ACE_CODESET_ID_IBM_1122 0x10020462U -#define ACE_CODESET_ID_IBM_1250 0x100204E2U -#define ACE_CODESET_ID_IBM_1251 0x100204E3U -#define ACE_CODESET_ID_IBM_1252 0x100204E4U -#define ACE_CODESET_ID_IBM_1253 0x100204E5U -#define ACE_CODESET_ID_IBM_1254 0x100204E6U -#define ACE_CODESET_ID_IBM_1255 0x100204E7U -#define ACE_CODESET_ID_IBM_1256 0x100204E8U -#define ACE_CODESET_ID_IBM_1257 0x100204E9U -#define ACE_CODESET_ID_IBM_1380 0x10020564U -#define ACE_CODESET_ID_IBM_1381 0x10020565U -#define ACE_CODESET_ID_IBM_1383 0x10020567U -#define ACE_CODESET_ID_IBM_4396 0x1002112CU -#define ACE_CODESET_ID_IBM_4946 0x10021352U -#define ACE_CODESET_ID_IBM_4948 0x10021354U -#define ACE_CODESET_ID_IBM_4951 0x10021357U -#define ACE_CODESET_ID_IBM_4952 0x10021358U -#define ACE_CODESET_ID_IBM_4953 0x10021359U -#define ACE_CODESET_ID_IBM_4960 0x10021360U -#define ACE_CODESET_ID_IBM_4964 0x10021364U -#define ACE_CODESET_ID_IBM_4965 0x10021365U -#define ACE_CODESET_ID_IBM_5026 0x100213A2U -#define ACE_CODESET_ID_IBM_5031 0x100213A7U -#define ACE_CODESET_ID_IBM_5035 0x100213ABU -#define ACE_CODESET_ID_IBM_5048 0x100213B8U -#define ACE_CODESET_ID_IBM_5049 0x100213B9U -#define ACE_CODESET_ID_IBM_5067 0x100213CBU -#define ACE_CODESET_ID_IBM_8612 0x100221A4U -#define ACE_CODESET_ID_IBM_9025 0x10022341U -#define ACE_CODESET_ID_IBM_9026 0x10022342U -#define ACE_CODESET_ID_IBM_9030 0x10022346U -#define ACE_CODESET_ID_IBM_9056 0x10022360U -#define ACE_CODESET_ID_IBM_9066 0x1002236AU -#define ACE_CODESET_ID_IBM_9125 0x100223A5U -#define ACE_CODESET_ID_IBM_25426 0x10026352U -#define ACE_CODESET_ID_IBM_25432 0x10026358U -#define ACE_CODESET_ID_IBM_1042 0x10026412U -#define ACE_CODESET_ID_IBM_28709 0x10027025U -#define ACE_CODESET_ID_IBM_33624 0x10028358U -#define ACE_CODESET_ID_IBM_33722 0x100283BAU -#define ACE_CODESET_ID_HTCSJIS 0x10030001U -#define ACE_CODESET_ID_HTCUJIS 0x10030002U -#define ACE_CODESET_ID_FUJITSU_U90 0x10040001U -#define ACE_CODESET_ID_FUJITSU_S90 0x10040002U -#define ACE_CODESET_ID_FUJITSU_R90 0x10040003U -#define ACE_CODESET_ID_EBCDIC_ASCII_AND_JEF 0x10040004U -#define ACE_CODESET_ID_EBCDIC_KATAKANA_AND_JEF 0x10040005U -#define ACE_CODESET_ID_EBCDIC_JAPANESE_ENGLISH_AND_JEF 0x10040006U - -#define ACE_CODESET_ID_TAO_BACKWARD_COMPATIBLE 0xf54414F0U -#endif // CODESET_SYMBOLS_H diff --git a/deps/acelite/ace/Condition_Attributes.cpp b/deps/acelite/ace/Condition_Attributes.cpp deleted file mode 100644 index 9257b602d..000000000 --- a/deps/acelite/ace/Condition_Attributes.cpp +++ /dev/null @@ -1,15 +0,0 @@ -/* -*- C++ -*- */ -/** - * @file Condition_Attributes.cpp - * - * Originally in Synch.cpp - * - * @author Douglas C. Schmidt - */ - -#include "ace/Condition_Thread_Mutex.h" -#include "ace/Condition_Attributes.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Condition_Attributes.inl" -#endif /* __ACE_INLINE__ */ diff --git a/deps/acelite/ace/Condition_Attributes.h b/deps/acelite/ace/Condition_Attributes.h deleted file mode 100644 index 06b2676d8..000000000 --- a/deps/acelite/ace/Condition_Attributes.h +++ /dev/null @@ -1,93 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Condition_Attributes.h - * - * Moved from Synch.h. - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_CONDITION_ATTRIBUTES_H -#define ACE_CONDITION_ATTRIBUTES_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/OS_NS_Thread.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Export ACE_Condition_Attributes -{ -public: - /// Constructor - ACE_Condition_Attributes (int type = ACE_DEFAULT_SYNCH_TYPE); - - /// Destructor - ~ACE_Condition_Attributes (void); - - /// Accessor for retrieving the current attributes - const ACE_condattr_t& attributes (void) const; - -protected: - /// The attributes - ACE_condattr_t attributes_; - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Condition_Attributes &); - ACE_Condition_Attributes (const ACE_Condition_Attributes &); -}; - -template -class ACE_Condition_Attributes_T : public ACE_Condition_Attributes -{ -public: - /// Constructor - ACE_Condition_Attributes_T (int type = ACE_DEFAULT_SYNCH_TYPE) - : ACE_Condition_Attributes (type) - {} - - /// Destructor - ~ACE_Condition_Attributes_T (void) {} - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Condition_Attributes_T &); - ACE_Condition_Attributes_T (const ACE_Condition_Attributes_T &); -}; - -class ACE_Monotonic_Time_Policy; - -template <> -class ACE_Export ACE_Condition_Attributes_T - : public ACE_Condition_Attributes -{ -public: - /// Constructor - ACE_Condition_Attributes_T (int type = ACE_DEFAULT_SYNCH_TYPE); - - /// Destructor - ~ACE_Condition_Attributes_T (void); - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Condition_Attributes_T &); - ACE_Condition_Attributes_T (const ACE_Condition_Attributes_T &); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Condition_Attributes.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_CONDITION_ATTRIBUTES_H */ diff --git a/deps/acelite/ace/Condition_Attributes.inl b/deps/acelite/ace/Condition_Attributes.inl deleted file mode 100644 index f63106ad4..000000000 --- a/deps/acelite/ace/Condition_Attributes.inl +++ /dev/null @@ -1,37 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Condition_Attributes::ACE_Condition_Attributes (int type) -{ - (void) ACE_OS::condattr_init (this->attributes_, type); -} - -ACE_INLINE -ACE_Condition_Attributes::~ACE_Condition_Attributes (void) -{ - ACE_OS::condattr_destroy (this->attributes_); -} - -ACE_INLINE -const ACE_condattr_t& -ACE_Condition_Attributes::attributes (void) const -{ - return this->attributes_; -} - -ACE_INLINE -ACE_Condition_Attributes_T::ACE_Condition_Attributes_T (int type) - : ACE_Condition_Attributes (type) -{ -#if defined (ACE_HAS_POSIX_MONOTONIC_CONDITIONS) - (void) ACE_OS::condattr_setclock (this->attributes_, CLOCK_MONOTONIC); -#endif -} - -ACE_INLINE -ACE_Condition_Attributes_T::~ACE_Condition_Attributes_T (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Condition_Recursive_Thread_Mutex.cpp b/deps/acelite/ace/Condition_Recursive_Thread_Mutex.cpp deleted file mode 100644 index e7a23dfe7..000000000 --- a/deps/acelite/ace/Condition_Recursive_Thread_Mutex.cpp +++ /dev/null @@ -1,131 +0,0 @@ -// -*- C++ -*- - -/** - * @file Condition_Recursive_Thread_Mutex.cpp - * - * Originally in Synch.cpp - * - * @author Douglas C. Schmidt - */ - -#include "ace/Condition_Recursive_Thread_Mutex.h" - -#if defined (ACE_HAS_THREADS) - -#include "ace/Log_Category.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -int -ACE_Condition::remove (void) -{ - return ACE_OS::cond_destroy (&this->cond_); -} - -void -ACE_Condition::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Condition::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - // No dump method for ACE_cond_t even in emulated mode. - // cond_.dump (); - this->mutex_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n"))); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Condition::~ACE_Condition (void) -{ - this->remove (); -} - -ACE_Condition::ACE_Condition (ACE_Recursive_Thread_Mutex &m) - : mutex_ (m) -{ - if (ACE_OS::cond_init (&this->cond_) != 0) - ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Condition::ACE_Condition"))); -} - -ACE_Condition::ACE_Condition (ACE_Recursive_Thread_Mutex &m, - const ACE_Condition_Attributes &attributes) - : mutex_ (m) -{ - if (ACE_OS::cond_init (&this->cond_, - const_cast (attributes.attributes ())) != 0) - ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Condition::ACE_Condition"))); -} - -int -ACE_Condition::wait (const ACE_Time_Value *abstime) -{ - return this->wait (this->mutex_, abstime); -} - -int -ACE_Condition::wait (ACE_Recursive_Thread_Mutex &mutex, - const ACE_Time_Value *abstime) -{ - ACE_recursive_mutex_state mutex_state_holder; - ACE_recursive_thread_mutex_t &recursive_mutex = mutex.lock (); - - if (ACE_OS::recursive_mutex_cond_unlock (&recursive_mutex, - mutex_state_holder) == -1) - return -1; - - // We wait on the condition, specifying the nesting mutex. For platforms - // with ACE_HAS_RECURSIVE_MUTEXES, this is the recursive mutex itself, - // and is the same as recursive_mutex, above. The caller should have been - // holding the lock on entry to this method, and it is still held. - // For other platforms, this is the nesting mutex that guards the - // ACE_recursive_mutex_t internals, and recursive_mutex_cond_unlock() - // returned with the lock held, but waiters primed and waiting to be - // released. At cond_wait below, the mutex will be released. - // On return, it will be reacquired. - int const result = abstime == 0 - ? ACE_OS::cond_wait (&this->cond_, - &mutex.get_nesting_mutex ()) - : ACE_OS::cond_timedwait (&this->cond_, - &mutex.get_nesting_mutex (), - const_cast (abstime)); - // We are holding the mutex, whether the wait succeeded or failed. - // Stash errno (in case it failed) and then we need to reset the - // recursive mutex state to what it was on entry to this method. - // Resetting it may require a wait for another thread to release - // the ACE_recursive_thread_mutex_t if this is a platform without - // ACE_HAS_RECURSIVE_MUTEXES, and recursive_mutex_cond_relock() takes - // care of that. - { - ACE_Errno_Guard error (errno); - ACE_OS::recursive_mutex_cond_relock (&recursive_mutex, - mutex_state_holder); - } - - return result; -} - -int -ACE_Condition::signal (void) -{ - return ACE_OS::cond_signal (&this->cond_); -} - -int -ACE_Condition::broadcast (void) -{ - return ACE_OS::cond_broadcast (&this->cond_); -} - -ACE_Recursive_Thread_Mutex & -ACE_Condition::mutex (void) -{ - return this->mutex_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_THREADS */ diff --git a/deps/acelite/ace/Condition_Recursive_Thread_Mutex.h b/deps/acelite/ace/Condition_Recursive_Thread_Mutex.h deleted file mode 100644 index f53ab12eb..000000000 --- a/deps/acelite/ace/Condition_Recursive_Thread_Mutex.h +++ /dev/null @@ -1,109 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Condition_Recursive_Thread_Mutex.h - * - * Moved from Synch.h. - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_CONDITION_RECURSIVE_THREAD_MUTEX_H -#define ACE_CONDITION_RECURSIVE_THREAD_MUTEX_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (ACE_HAS_THREADS) -# include "ace/Null_Condition.h" -#else /* ACE_HAS_THREADS */ -#include "ace/Recursive_Thread_Mutex.h" -#include "ace/Condition_Attributes.h" -#include "ace/Condition_T.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @brief ACE_Condition template specialization written using - * @a ACE_Recursive_Thread_Mutex. This allows threads to block until - * shared data changes state using recursive mutexes. - */ -template<> -class ACE_Export ACE_Condition -{ -public: - /// Initialize the condition variable with a recursive mutex. - ACE_Condition (ACE_Recursive_Thread_Mutex &m); - - /// Initialize the condition variable. - ACE_Condition (ACE_Recursive_Thread_Mutex &m, - const ACE_Condition_Attributes &attributes); - - /// Implicitly destroy the condition variable. - ~ACE_Condition (void); - - /** - * Explicitly destroy the condition variable. Note that only one - * thread should call this method since it doesn't protect against - * race conditions. - */ - int remove (void); - - /** - * Block on condition, or until absolute time-of-day has passed. If - * abstime == 0 use "blocking" semantics. Else, if @a abstime - * != 0 and the call times out before the condition is signaled - * returns -1 and sets errno to ETIME. - */ - int wait (const ACE_Time_Value *abstime = 0); - - /** - * Block on condition or until absolute time-of-day has passed. If - * abstime == 0 use "blocking" wait() semantics on the recursive @a mutex - * passed as a parameter (this is useful if you need to store the - * in shared memory). Else, if @a abstime != 0 and the - * call times out before the condition is signaled returns -1 - * and sets errno to ETIME. - */ - int wait (ACE_Recursive_Thread_Mutex &mutex, - const ACE_Time_Value *abstime = 0); - - /// Signal one waiting thread. - int signal (void); - - /// Signal *all* waiting threads. - int broadcast (void); - - /// Returns a reference to the underlying mutex; - ACE_Recursive_Thread_Mutex &mutex (void); - - /// Dump the state of an object. - void dump (void) const; - -private: - // = Prevent assignment and copying. - void operator= (const ACE_Condition &); - ACE_Condition (const ACE_Condition &); - -private: - /// A normal (i.e., non-recursive) condition variable. - ACE_cond_t cond_; - - /// Reference to the recursive mutex. - ACE_Recursive_Thread_Mutex &mutex_; -}; - -typedef ACE_Condition ACE_Condition_Recursive_Thread_Mutex; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* !ACE_HAS_THREADS */ - -#include /**/ "ace/post.h" -#endif /* ACE_CONDITION_RECURSIVE_THREAD_MUTEX_H */ diff --git a/deps/acelite/ace/Condition_T.cpp b/deps/acelite/ace/Condition_T.cpp deleted file mode 100644 index 7f6b16737..000000000 --- a/deps/acelite/ace/Condition_T.cpp +++ /dev/null @@ -1,146 +0,0 @@ -#ifndef ACE_CONDITION_T_CPP -#define ACE_CONDITION_T_CPP - -#include "ace/Condition_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_THREADS) - -#include "ace/Log_Category.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/Condition_T.inl" -#include "ace/Time_Value.h" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Condition) -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Thread_Condition) - -template void -ACE_Condition::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Condition::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n"))); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Thread_Condition::ACE_Thread_Condition (MUTEX &m, - const ACE_TCHAR *name, - void *arg) - : ACE_Condition (m, USYNC_THREAD, name, arg) -{ -// ACE_TRACE ("ACE_Thread_Condition::ACE_Thread_Condition"); -} - -template void -ACE_Thread_Condition::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Thread_Condition::dump"); - - ACE_Condition::dump (); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Condition::ACE_Condition (MUTEX &m, - int type, - const ACE_TCHAR *name, - void *arg) - : - mutex_ (m) -{ - // ACE_TRACE ("ACE_Condition::ACE_Condition"); - - if (ACE_OS::cond_init (&this->cond_, - (short) type, - name, - arg) != 0) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Condition::ACE_Condition"))); -} - -template -ACE_Condition::ACE_Condition (MUTEX &m, - const ACE_Condition_Attributes &attributes, - const ACE_TCHAR *name, - void *arg) - : mutex_ (m) -{ -// ACE_TRACE ("ACE_Condition::ACE_Condition"); - if (ACE_OS::cond_init (&this->cond_, - const_cast (attributes.attributes ()), - name, arg) != 0) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Condition::ACE_Condition"))); -} - -template -ACE_Condition::~ACE_Condition (void) -{ - // ACE_TRACE ("ACE_Condition::~ACE_Condition"); - - if (this->remove () == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Condition::~ACE_Condition"))); -} - -template int -ACE_Condition::wait (void) -{ - // ACE_TRACE ("ACE_Condition::wait"); - return ACE_OS::cond_wait (&this->cond_, - &this->mutex_.lock ()); -} - -template int -ACE_Condition::wait (MUTEX &mutex, - const ACE_Time_Value *abstime) -{ -// ACE_TRACE ("ACE_Condition::wait"); - if (abstime == 0) - { - return ACE_OS::cond_wait (&this->cond_, - &mutex.lock ()); - } - else - { - ACE_Time_Value tv = *abstime; - return ACE_OS::cond_timedwait (&this->cond_, - &mutex.lock (), - &tv); - } -} - -// Peform an "alertable" timed wait. If the argument ABSTIME == 0 -// then we do a regular cond_wait(), else we do a timed wait for up to -// ABSTIME using the Solaris cond_timedwait() function. - -template int -ACE_Condition::wait (const ACE_Time_Value *abstime) -{ -// ACE_TRACE ("ACE_Condition::wait"); - return this->wait (this->mutex_, abstime); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_THREADS */ - -#endif /* ACE_CONDITION_T_CPP */ diff --git a/deps/acelite/ace/Condition_T.h b/deps/acelite/ace/Condition_T.h deleted file mode 100644 index d87d96b2d..000000000 --- a/deps/acelite/ace/Condition_T.h +++ /dev/null @@ -1,169 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Condition_T.h - * - * Moved from Synch.h. - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_CONDITION_T_H -#define ACE_CONDITION_T_H - -#include /**/ "ace/pre.h" - -#include "ace/OS_NS_Thread.h" -#include "ace/Condition_Attributes.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_THREADS) /* ACE platform supports some form of threading. */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Time_Value; - -/** - * @class ACE_Condition - * - * @brief ACE_Condition variable wrapper, which allows threads to block - * until shared data changes state. - * - * A condition variable enables threads to atomically block and - * test the condition under the protection of a mutual exclusion - * lock (mutex) until the condition is satisfied. That is, - * the mutex must have been held by the thread before calling - * wait or signal on the condition. If the condition is false, - * a thread blocks on a condition variable and atomically - * releases the mutex that is waiting for the condition to - * change. If another thread changes the condition, it may wake - * up waiting threads by signaling the associated condition - * variable. The waiting threads, upon awakening, reacquire the - * mutex and re-evaluate the condition. - * Note, you can only parameterize with - * @a ACE_Thread_Mutex, @a ACE_Recursive_Thread_Mutex, or @a ACE_Null_Mutex. - */ -template -class ACE_Condition -{ -public: - /// Initialize the condition variable. - ACE_Condition (MUTEX &m, int type = USYNC_THREAD, - const ACE_TCHAR *name = 0, void *arg = 0); - - /// Initialize the condition variable. - ACE_Condition (MUTEX &m, - const ACE_Condition_Attributes &attributes, - const ACE_TCHAR *name = 0, - void *arg = 0); - - /// Implicitly destroy the condition variable. - ~ACE_Condition (void); - - // = Lock accessors. - /** - * Block on condition, or until absolute time-of-day has passed. If - * @a abstime == 0 use "blocking" semantics. Else, if @a abstime - * != 0 and the call times out before the condition is signaled - * wait() returns -1 and sets errno to ETIME. - */ - int wait (const ACE_Time_Value *abstime); - - /// Block on condition. - int wait (void); - - /** - * Block on condition or until absolute time-of-day has passed. If - * @a abstime == 0 use "blocking" wait() semantics on the @a mutex - * passed as a parameter (this is useful if you need to store the - * in shared memory). Else, if @a abstime != 0 and the - * call times out before the condition is signaled wait() returns -1 - * and sets errno to ETIME. - */ - int wait (MUTEX &mutex, const ACE_Time_Value *abstime = 0); - - /// Signal one waiting thread. - int signal (void); - - /// Signal *all* waiting threads. - int broadcast (void); - - // = Utility methods. - /// Explicitly destroy the condition variable. - int remove (void); - - /// Returns a reference to the underlying mutex_; - MUTEX &mutex (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Condition variable. - ACE_cond_t cond_; - - /// Reference to mutex lock. - MUTEX &mutex_; - -private: - // = Prevent assignment and initialization. - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Condition &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Condition (const ACE_Condition &)) -}; - -/** - * @class ACE_Thread_Condition - * - * @brief ACE_Condition variable wrapper that works within processes. - * - * A condition variable enables threads to atomically block and - * test the condition under the protection of a mutual exclu- - * sion lock (mutex) until the condition is satisfied. That is, - * the mutex must have been held by the thread before calling - * wait or signal on the condition. If the condition is false, - * a thread blocks on a condition variable and atomically - * releases the mutex that is waiting for the condition to - * change. If another thread changes the condition, it may wake - * up waiting threads by signaling the associated condition - * variable. The waiting threads, upon awakening, reacquire the - * mutex and re-evaluate the condition. - */ -template -class ACE_Thread_Condition : public ACE_Condition -{ -public: - ACE_Thread_Condition (MUTEX &m, const ACE_TCHAR *name = 0, void *arg = 0); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Condition_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Condition_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Condition_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#endif /* ACE_HAS_THREADS */ - -#include /**/ "ace/post.h" -#endif /* ACE_CONDITION_T_H */ diff --git a/deps/acelite/ace/Condition_T.inl b/deps/acelite/ace/Condition_T.inl deleted file mode 100644 index dc4266229..000000000 --- a/deps/acelite/ace/Condition_T.inl +++ /dev/null @@ -1,48 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE int -ACE_Condition::remove (void) -{ - // ACE_TRACE ("ACE_Condition::remove"); - - // cond_destroy() is called in a loop if the condition variable is - // BUSY. This avoids a condition where a condition is signaled and - // because of some timing problem, the thread that is to be signaled - // has called the cond_wait routine after the signal call. Since - // the condition signal is not queued in any way, deadlock occurs. - - int result = 0; - - while ((result = ACE_OS::cond_destroy (&this->cond_)) == -1 - && errno == EBUSY) - { - ACE_OS::cond_broadcast (&this->cond_); - ACE_OS::thr_yield (); - } - - return result; -} - -template ACE_INLINE MUTEX & -ACE_Condition::mutex (void) -{ - // ACE_TRACE ("ACE_Condition::mutex"); - return this->mutex_; -} - -template ACE_INLINE int -ACE_Condition::signal (void) -{ -// ACE_TRACE ("ACE_Condition::signal"); - return ACE_OS::cond_signal (&this->cond_); -} - -template ACE_INLINE int -ACE_Condition::broadcast (void) -{ -// ACE_TRACE ("ACE_Condition::broadcast"); - return ACE_OS::cond_broadcast (&this->cond_); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Condition_Thread_Mutex.cpp b/deps/acelite/ace/Condition_Thread_Mutex.cpp deleted file mode 100644 index 7e9c505d4..000000000 --- a/deps/acelite/ace/Condition_Thread_Mutex.cpp +++ /dev/null @@ -1,122 +0,0 @@ -/* -*- C++ -*- */ -/** - * @file Condition_Thread_Mutex.cpp - * - * Originally in Synch.cpp - * - * @author Douglas C. Schmidt - */ - -#include "ace/Condition_Thread_Mutex.h" - -#if defined (ACE_HAS_THREADS) - -#if !defined (__ACE_INLINE__) -#include "ace/Condition_Thread_Mutex.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Log_Category.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Condition) - -void -ACE_Condition::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Condition::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n"))); -#if defined (ACE_WIN32) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("waiters = %d\n"), - this->cond_.waiters ())); -#endif /* ACE_WIN32 */ - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Condition::ACE_Condition (ACE_Thread_Mutex &m, - const ACE_TCHAR *name, - void *arg) - : mutex_ (m), - removed_ (false) -{ -// ACE_TRACE ("ACE_Condition::ACE_Condition"); - if (ACE_OS::cond_init (&this->cond_, - (short) USYNC_THREAD, - name, - arg) != 0) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Condition::ACE_Condition"))); -} - -ACE_Condition::ACE_Condition (ACE_Thread_Mutex &m, - const ACE_Condition_Attributes &attributes, - const ACE_TCHAR *name, - void *arg) - : mutex_ (m), - removed_ (false) -{ -// ACE_TRACE ("ACE_Condition::ACE_Condition"); - if (ACE_OS::cond_init (&this->cond_, - const_cast (attributes.attributes ()), - name, arg) != 0) - ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Condition::ACE_Condition"))); -} - -ACE_Condition::~ACE_Condition (void) -{ -// ACE_TRACE ("ACE_Condition::~ACE_Condition"); - this->remove (); -} - -// Peform an "alertable" timed wait. If the argument == 0 -// then we do a regular , else we do a timed wait for up to -// using the function. - -int -ACE_Condition::wait (void) -{ -// ACE_TRACE ("ACE_Condition::wait"); - return ACE_OS::cond_wait (&this->cond_, &this->mutex_.lock ()); -} - -int -ACE_Condition::wait (ACE_Thread_Mutex &mutex, - const ACE_Time_Value *abstime) -{ -// ACE_TRACE ("ACE_Condition::wait"); - return ACE_OS::cond_timedwait (&this->cond_, - &mutex.lock (), - const_cast (abstime)); -} - -int -ACE_Condition::wait (const ACE_Time_Value *abstime) -{ -// ACE_TRACE ("ACE_Condition::wait"); - return this->wait (this->mutex_, abstime); -} - -int -ACE_Condition::signal (void) -{ -// ACE_TRACE ("ACE_Condition::signal"); - return ACE_OS::cond_signal (&this->cond_); -} - -int -ACE_Condition::broadcast (void) -{ -// ACE_TRACE ("ACE_Condition::broadcast"); - return ACE_OS::cond_broadcast (&this->cond_); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_THREADS */ diff --git a/deps/acelite/ace/Condition_Thread_Mutex.h b/deps/acelite/ace/Condition_Thread_Mutex.h deleted file mode 100644 index 898e683fa..000000000 --- a/deps/acelite/ace/Condition_Thread_Mutex.h +++ /dev/null @@ -1,144 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Condition_Thread_Mutex.h - * - * Moved from Synch.h. - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_CONDITION_THREAD_MUTEX_H -#define ACE_CONDITION_THREAD_MUTEX_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (ACE_HAS_THREADS) -# include "ace/Null_Condition.h" -#else /* ACE_HAS_THREADS */ -// ACE platform supports some form of threading. - -#include "ace/Thread_Mutex.h" -#include "ace/Condition_Attributes.h" -#include "ace/Condition_T.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Time_Value; - -/** - * @brief ACE_Condition template specialization written using - * ACE_Mutexes. This allows threads to block until shared data - * changes state. - * A condition variable enables threads to atomically block and - * test the condition under the protection of a mutual exclu- - * sion lock (mutex) until the condition is satisfied. That is, - * the mutex must have been held by the thread before calling - * wait or signal on the condition. If the condition is false, - * a thread blocks on a condition variable and atomically - * releases the mutex that is waiting for the condition to - * change. If another thread changes the condition, it may wake - * up waiting threads by signaling the associated condition - * variable. The waiting threads, upon awakening, reacquire the - * mutex and re-evaluate the condition. - */ -template <> -class ACE_Export ACE_Condition -{ -public: - /// Initialize the condition variable. - ACE_Condition (ACE_Thread_Mutex &m, - const ACE_TCHAR *name = 0, - void *arg = 0); - - /// Initialize the condition variable. - ACE_Condition (ACE_Thread_Mutex &m, - const ACE_Condition_Attributes &attributes, - const ACE_TCHAR *name = 0, - void *arg = 0); - - /// Implicitly destroy the condition variable. - ~ACE_Condition (void); - - /** - * Explicitly destroy the condition variable. Note that only one - * thread should call this method since it doesn't protect against - * race conditions. - */ - int remove (void); - - /** - * Block on condition, or until absolute time-of-day has passed. If - * abstime == 0 use "blocking" wait semantics. Else, if @a abstime - * != 0 and the call times out before the condition is signaled - * wait() returns -1 and sets errno to ETIME. - */ - int wait (const ACE_Time_Value *abstime); - - /// Block on condition. - int wait (void); - - /** - * Block on condition or until absolute time-of-day has passed. If - * abstime == 0 use "blocking" wait() semantics on the @a mutex - * passed as a parameter (this is useful if you need to store the - * in shared memory). Else, if @a abstime != 0 and the - * call times out before the condition is signaled returns -1 - * and sets errno to ETIME. - */ - int wait (ACE_Thread_Mutex &mutex, const ACE_Time_Value *abstime = 0); - - /// Signal one waiting thread. - int signal (void); - - /// Signal *all* waiting threads. - int broadcast (void); - - /// Returns a reference to the underlying mutex; - ACE_Thread_Mutex &mutex (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Condition variable. - ACE_cond_t cond_; - - /// Reference to mutex lock. - ACE_Thread_Mutex &mutex_; - - /// Keeps track of whether remove() has been called yet to avoid - /// multiple remove() calls, e.g., explicitly and implicitly in the - /// destructor. This flag isn't protected by a lock, so make sure - /// that you don't have multiple threads simultaneously calling - /// remove() on the same object, which is a bad idea anyway... - bool removed_; - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Condition &); - ACE_Condition (const ACE_Condition &); -}; - -typedef ACE_Condition ACE_Condition_Thread_Mutex; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Condition_Thread_Mutex.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* !ACE_HAS_THREADS */ - -#include /**/ "ace/post.h" -#endif /* ACE_CONDITION_THREAD_MUTEX_H */ diff --git a/deps/acelite/ace/Condition_Thread_Mutex.inl b/deps/acelite/ace/Condition_Thread_Mutex.inl deleted file mode 100644 index 5db2808d1..000000000 --- a/deps/acelite/ace/Condition_Thread_Mutex.inl +++ /dev/null @@ -1,38 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE int -ACE_Condition::remove (void) -{ -// ACE_TRACE ("ACE_Condition::remove"); - - // is called in a loop if the condition variable is - // BUSY. This avoids a condition where a condition is signaled and - // because of some timing problem, the thread that is to be signaled - // has called the cond_wait routine after the signal call. Since - // the condition signal is not queued in any way, deadlock occurs. - - int result = 0; - - if (!this->removed_) - { - this->removed_ = true; - - while ((result = ACE_OS::cond_destroy (&this->cond_)) == -1 - && errno == EBUSY) - { - ACE_OS::cond_broadcast (&this->cond_); - ACE_OS::thr_yield (); - } - } - return result; -} - -ACE_INLINE ACE_Thread_Mutex & -ACE_Condition::mutex (void) -{ -// ACE_TRACE ("ACE_Condition::mutex"); - return this->mutex_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Configuration.cpp b/deps/acelite/ace/Configuration.cpp deleted file mode 100644 index 10b0ad2b0..000000000 --- a/deps/acelite/ace/Configuration.cpp +++ /dev/null @@ -1,2152 +0,0 @@ -#include "ace/Configuration.h" -#include "ace/Auto_Ptr.h" -#include "ace/SString.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_NS_strings.h" -#include "ace/Tokenizer_T.h" - -#if !defined (ACE_LACKS_ACCESS) -# include "ace/OS_NS_unistd.h" -#endif /* ACE_LACKS_ACCESS */ - -#if !defined (__ACE_INLINE__) -#include "ace/Configuration.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Section_Key_Internal::ACE_Section_Key_Internal (void) - : ref_count_ (0) -{ -} - -ACE_Section_Key_Internal::~ACE_Section_Key_Internal (void) -{ -} - -int -ACE_Section_Key_Internal::add_ref (void) -{ - ++ref_count_; - return 0; -} - -int -ACE_Section_Key_Internal::dec_ref (void) -{ - if (!--ref_count_) - delete this; - return 0; -} - -ACE_Configuration_Section_Key::ACE_Configuration_Section_Key (void) - : key_ (0) -{ -} - -ACE_Configuration_Section_Key::~ACE_Configuration_Section_Key (void) -{ - if (key_) - key_->dec_ref (); -} - -ACE_Configuration_Section_Key::ACE_Configuration_Section_Key (ACE_Section_Key_Internal* key) - : key_ (key) -{ - if (key_) - key_->add_ref (); -} - -ACE_Configuration_Section_Key::ACE_Configuration_Section_Key (const ACE_Configuration_Section_Key& rhs) - : key_ (rhs.key_) -{ - if (key_) - key_->add_ref (); -} - -ACE_Configuration_Section_Key& -ACE_Configuration_Section_Key::operator= (const ACE_Configuration_Section_Key& rhs) -{ - if (this != &rhs) - { - if (key_) - key_->dec_ref (); - - key_ = rhs.key_; - - if (key_) - key_->add_ref (); - } - return *this; -} - -////////////////////////////////////////////////////////////////////////////// - -ACE_TCHAR ACE_Configuration::NULL_String_ = '\0'; - -ACE_Configuration::ACE_Configuration (void) - : root_ () -{ -} - -ACE_Configuration::~ACE_Configuration (void) -{ -} - -ACE_Section_Key_Internal* -ACE_Configuration::get_internal_key (const ACE_Configuration_Section_Key& key) -{ - return key.key_; -} - -int -ACE_Configuration::expand_path (const ACE_Configuration_Section_Key& key, - const ACE_TString& path_in, - ACE_Configuration_Section_Key& key_out, - bool create) -{ - // Make a copy of key - ACE_Configuration_Section_Key current_section = key; - ACE_Auto_Basic_Array_Ptr pData (path_in.rep ()); - ACE_Tokenizer parser (pData.get ()); - parser.delimiter_replace ('\\', '\0'); - parser.delimiter_replace ('/', '\0'); - - for (ACE_TCHAR *temp = parser.next (); - temp != 0; - temp = parser.next ()) - { - // Open the section - if (open_section (current_section, - temp, - create, - key_out)) - return -1; - - current_section = key_out; - } - - return 0; - -} - -int -ACE_Configuration::validate_name (const ACE_TCHAR* name, int allow_path) -{ - // Invalid character set - const ACE_TCHAR* reject = - allow_path ? ACE_TEXT ("][") : ACE_TEXT ("\\]["); - - // Position of the first invalid character or terminating null. - size_t const pos = ACE_OS::strcspn (name, reject); - - // Check if it is an invalid character. - if (name[pos] != ACE_TEXT ('\0')) - { - errno = EINVAL; - return -1; - } - - // The first character can never be a path separator. - if (name[0] == ACE_TEXT ('\\')) - { - errno = EINVAL; - return -1; - } - - // Validate length. - if (pos == 0 || pos > 255) - { - errno = ENAMETOOLONG; - return -1; - } - - return 0; -} - -int -ACE_Configuration::validate_value_name (const ACE_TCHAR* name) -{ - if (name == 0 || *name == this->NULL_String_) - return 0; - - return this->validate_name (name); -} - -const ACE_Configuration_Section_Key& -ACE_Configuration::root_section (void) const -{ - return root_; -} - -/** - * Determine if the contents of this object is the same as the - * contents of the object on the right hand side. - * Returns 1 (True) if they are equal and 0 (False) if they are not equal - */ -bool -ACE_Configuration::operator== (const ACE_Configuration& rhs) const -{ - bool rc = true; - int sectionIndex = 0; - ACE_TString sectionName; - ACE_Configuration *nonconst_this = const_cast (this); - ACE_Configuration &nonconst_rhs = const_cast (rhs); - - const ACE_Configuration_Section_Key& rhsRoot = rhs.root_section (); - ACE_Configuration_Section_Key rhsSection; - ACE_Configuration_Section_Key thisSection; - - // loop through each section in this object - while ((rc) && (nonconst_this->enumerate_sections (this->root_, - sectionIndex, - sectionName) == 0)) - { - // find that section in the rhs object - if (nonconst_rhs.open_section (rhsRoot, - sectionName.c_str (), - 0, - rhsSection) != 0) - { - // If the rhs object does not contain the section then we are - // not equal. - rc = false; - } - else if (nonconst_this->open_section (this->root_, - sectionName.c_str (), - 0, - thisSection) != 0) - { - // if there is some error opening the section in this object - rc = false; - } - else - { - // Well the sections match - int valueIndex = 0; - ACE_TString valueName; - VALUETYPE valueType; - VALUETYPE rhsType; - - // Enumerate each value in this section - while ((rc) && nonconst_this->enumerate_values (thisSection, - valueIndex, - valueName, - valueType) == 0) - { - // look for the same value in the rhs section - if (nonconst_rhs.find_value (rhsSection, - valueName.c_str (), - rhsType) != 0) - { - // We're not equal if the same value cannot - // be found in the rhs object. - rc = false; - } - else if (valueType != rhsType) - { - // we're not equal if the types do not match. - rc = false; - } - else - { - // finally compare values. - if (valueType == STRING) - { - ACE_TString thisString, rhsString; - if (nonconst_this->get_string_value (thisSection, - valueName.c_str (), - thisString) != 0) - { - // we're not equal if we cannot get this string - rc = false; - } - else if (nonconst_rhs.get_string_value ( - rhsSection, - valueName.c_str (), - rhsString) != 0) - { - // we're not equal if we cannot get rhs string - rc = false; - } - rc = (thisString == rhsString); - } - else if (valueType == INTEGER) - { - u_int thisInt = 0; - u_int rhsInt = 0; - if (nonconst_this->get_integer_value ( - thisSection, - valueName.c_str (), - thisInt) != 0) - { - // we're not equal if we cannot get this int - rc = false; - } - else if (nonconst_rhs.get_integer_value ( - rhsSection, - valueName.c_str (), - rhsInt) != 0) - { - // we're not equal if we cannot get rhs int - rc = false; - } - rc = (thisInt == rhsInt); - } - else if (valueType == BINARY) - { - void* thisData = 0; - void* rhsData = 0; - size_t thisLength = 0; - size_t rhsLength = 0; - if (nonconst_this->get_binary_value (thisSection, - valueName.c_str (), - thisData, - thisLength) != 0) - { - // we're not equal if we cannot get this data - rc = false; - } - else if (nonconst_rhs.get_binary_value ( - rhsSection, - valueName.c_str (), - rhsData, - rhsLength) != 0) - { - // we're not equal if we cannot get this data - rc = false; - } - - rc = (thisLength == rhsLength); - // are the length's the same? - - if (rc) - { - unsigned char* thisCharData = - (unsigned char*)thisData; - unsigned char* rhsCharData = (unsigned char*)rhsData; - // yes, then check each element - for (size_t count = 0; - (rc) && (count < thisLength); - count++) - { - rc = (* (thisCharData + count) == * (rhsCharData + count)); - } - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(thisCharData); - ACE_Allocator::instance()->free(rhsCharData); -#else - delete [] thisCharData; - delete [] rhsCharData; -#endif /* ACE_HAS_ALLOC_HOOKS */ - }// end if the length's match - } - // We should never have valueTypes of INVALID, therefore - // we're not comparing them. How would we since we have - // no get operation for invalid types. - // So, if we have them, we guess they are equal. - - }// end else if values match. - - ++valueIndex; - - }// end value while loop - - // look in the rhs for values not in this - valueIndex = 0; - while ((rc) && (nonconst_rhs.enumerate_values (rhsSection, - valueIndex, - valueName, - rhsType) == 0)) - { - // look for the same value in this section - if (nonconst_this->find_value (thisSection, - valueName.c_str (), - valueType) != 0) - { - // We're not equal if the same value cannot - // be found in the rhs object. - rc = false; - } - ++valueIndex; - }// end while for rhs values not in this. - - }// end else if sections match. - - ++sectionIndex; - - }// end section while loop - - // Finally, make sure that there are no sections in rhs that do not - // exist in this - sectionIndex = 0; - while ((rc) - && (nonconst_rhs.enumerate_sections (rhsRoot, - sectionIndex, - sectionName) == 0)) - { - // find the section in this - if (nonconst_this->open_section (this->root_, - sectionName.c_str (), - 0, - thisSection) != 0) - { - // if there is some error opening the section in this object - rc = false; - } - else if (nonconst_rhs.open_section (rhsRoot, - sectionName.c_str (), - 0, - rhsSection) != 0) - { - // If the rhs object does not contain the section then we - // are not equal. - rc = false; - } - ++sectionIndex; - } - return rc; -} - -bool -ACE_Configuration::operator!= (const ACE_Configuration& rhs) const -{ - return !(*this == rhs); -} - -////////////////////////////////////////////////////////////////////////////// - -#if defined (ACE_WIN32) && !defined (ACE_LACKS_WIN32_REGISTRY) - -static const int ACE_DEFAULT_BUFSIZE = 256; - -static const ACE_TCHAR *temp_name (const ACE_TCHAR *name) -{ - if (name && *name == ACE_Configuration::NULL_String_) - return 0; - return name; -} - -ACE_Section_Key_Win32::ACE_Section_Key_Win32 (HKEY hKey) - : hKey_ (hKey) -{ -} - -ACE_Section_Key_Win32::~ACE_Section_Key_Win32 (void) -{ - ::RegCloseKey (hKey_); -} - -////////////////////////////////////////////////////////////////////////////// - -bool -ACE_Configuration_Win32Registry::operator== (const ACE_Configuration_Win32Registry &rhs) const -{ - ACE_UNUSED_ARG (rhs); - return true; -} - -bool -ACE_Configuration_Win32Registry::operator!= (const ACE_Configuration_Win32Registry &rhs) const -{ - ACE_UNUSED_ARG (rhs); - return true; -} - -ACE_Configuration_Win32Registry::ACE_Configuration_Win32Registry (HKEY hKey, u_long security_access) - : security_access_ (security_access) -{ - ACE_Section_Key_Win32 *temp = 0; - - ACE_NEW (temp, ACE_Section_Key_Win32 (hKey)); - - root_ = ACE_Configuration_Section_Key (temp); -} - - -ACE_Configuration_Win32Registry::~ACE_Configuration_Win32Registry (void) -{ -} - -int -ACE_Configuration_Win32Registry::open_section (const ACE_Configuration_Section_Key& base, - const ACE_TCHAR* sub_section, - bool create, - ACE_Configuration_Section_Key& result) -{ - if (validate_name (sub_section, 1)) - return -1; - - HKEY base_key; - if (load_key (base, base_key)) - return -1; - - int errnum; - HKEY result_key; - if ((errnum = ACE_TEXT_RegOpenKeyEx (base_key, - sub_section, - 0, - security_access_, - &result_key)) != ERROR_SUCCESS) - { - if (!create) - { - errno = errnum; - return -1; - } - - if ((errnum = ACE_TEXT_RegCreateKeyEx (base_key, - sub_section, - 0, - 0, - REG_OPTION_NON_VOLATILE, - security_access_, - 0, - &result_key, - (PDWORD) 0 - )) != ERROR_SUCCESS) - { - errno = errnum; - return -1; - } - } - - ACE_Section_Key_Win32 *temp; - - ACE_NEW_RETURN (temp, ACE_Section_Key_Win32 (result_key), -1); - result = ACE_Configuration_Section_Key (temp); - return 0; -} - -int -ACE_Configuration_Win32Registry::remove_section (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* sub_section, - bool recursive) -{ - if (validate_name (sub_section)) - return -1; - - HKEY base_key; - if (load_key (key, base_key)) - return -1; - - if (recursive) - { - ACE_Configuration_Section_Key section; - if (open_section (key, sub_section, 0, section)) - return -1; - - HKEY sub_key; - if (load_key (section, sub_key)) - return -1; - - ACE_TCHAR name_buffer[ACE_DEFAULT_BUFSIZE]; - DWORD buffer_size = ACE_DEFAULT_BUFSIZE; - // Note we don't increment the index because the - // enumeration becomes invalid if we change the - // subkey, which we do when we delete it. By leaving - // it 0, we always delete the top entry - while (ACE_TEXT_RegEnumKeyEx (sub_key, - 0, - name_buffer, - &buffer_size, - 0, - 0, - 0, - 0) == ERROR_SUCCESS) - { - remove_section (section, name_buffer, true); - buffer_size = ACE_DEFAULT_BUFSIZE; - } - } - - int const errnum = ACE_TEXT_RegDeleteKey (base_key, sub_section); - if (errnum != ERROR_SUCCESS) - { - errno = errnum; - return -1; - } - - return 0; -} - -int -ACE_Configuration_Win32Registry::enumerate_values (const ACE_Configuration_Section_Key& key, - int index, - ACE_TString& name, - VALUETYPE& type) -{ - HKEY base_key; - if (load_key (key, base_key)) - return -1; - - ACE_TCHAR name_buffer[ACE_DEFAULT_BUFSIZE]; - DWORD buffer_size = ACE_DEFAULT_BUFSIZE; - DWORD value_type; - - int rc = ACE_TEXT_RegEnumValue (base_key, - index, - name_buffer, - &buffer_size, - 0, - &value_type, - 0, - 0); - if (rc == ERROR_NO_MORE_ITEMS) - return 1; - else if (rc != ERROR_SUCCESS) - { - errno = rc; - return -1; - } - - name = name_buffer; - - switch (value_type) - { - case REG_BINARY: - type = BINARY; - break; - case REG_SZ: - type = STRING; - break; - case REG_DWORD: - type = INTEGER; - break; - default: - type = INVALID; - } - - return 0; -} - -int -ACE_Configuration_Win32Registry::enumerate_sections (const ACE_Configuration_Section_Key& key, - int index, - ACE_TString& name) -{ - HKEY base_key; - if (load_key (key, base_key)) - return -1; - - ACE_TCHAR name_buffer[ACE_DEFAULT_BUFSIZE]; - DWORD buffer_size = ACE_DEFAULT_BUFSIZE; - int rc = ACE_TEXT_RegEnumKeyEx (base_key, - index, - name_buffer, - &buffer_size, - 0, - 0, - 0, - 0); - if (rc == ERROR_NO_MORE_ITEMS) - return 1; - else if (rc != ERROR_MORE_DATA && rc != ERROR_SUCCESS) - { - errno = rc; - return -1; - } - - name = name_buffer; - - return 0; -} - -int -ACE_Configuration_Win32Registry::set_string_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - const ACE_TString& value) -{ - const ACE_TCHAR *t_name = temp_name (name); - if (validate_value_name (t_name)) - return -1; - - HKEY base_key; - if (load_key (key, base_key)) - return -1; - - int errnum; - DWORD len = static_cast (value.length () + 1); - len *= sizeof (ACE_TCHAR); - if ((errnum = ACE_TEXT_RegSetValueEx (base_key, - t_name, - 0, - REG_SZ, - (BYTE *) value.fast_rep (), - len)) - != ERROR_SUCCESS) - { - errno = errnum; - return -1; - } - - return 0; -} - -int -ACE_Configuration_Win32Registry::set_integer_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - u_int value) -{ - const ACE_TCHAR *t_name = temp_name (name); - if (validate_value_name (t_name)) - return -1; - - HKEY base_key; - if (load_key (key, base_key)) - return -1; - - int errnum; - if ((errnum = ACE_TEXT_RegSetValueEx (base_key, - t_name, - 0, - REG_DWORD, - (BYTE *) &value, - sizeof (value))) != ERROR_SUCCESS) - { - errno = errnum; - return -1; - } - - return 0; -} - -int -ACE_Configuration_Win32Registry::set_binary_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - const void* data, - size_t length) -{ - const ACE_TCHAR *t_name = temp_name (name); - if (validate_value_name (t_name)) - return -1; - - HKEY base_key; - if (load_key (key, base_key)) - return -1; - - int errnum; - if ((errnum = ACE_TEXT_RegSetValueEx (base_key, - t_name, - 0, - REG_BINARY, - (BYTE *) data, - static_cast (length))) - != ERROR_SUCCESS) - { - errno = errnum; - return -1; - } - - return 0; -} - -int -ACE_Configuration_Win32Registry::get_string_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - ACE_TString& value) -{ - const ACE_TCHAR *t_name = temp_name (name); - if (validate_value_name (t_name)) - return -1; - - HKEY base_key; - if (load_key (key, base_key)) - return -1; - - // Get the size of the binary data from windows - int errnum; - DWORD buffer_length = 0; - DWORD type; - if ((errnum = ACE_TEXT_RegQueryValueEx (base_key, - t_name, - 0, - &type, - (BYTE *) 0, - &buffer_length)) != ERROR_SUCCESS) - { - errno = errnum; - return -1; - } - - if (type != REG_SZ) - { - errno = ERROR_INVALID_DATATYPE; - return -1; - } - - ACE_TCHAR *temp = 0; - ACE_NEW_RETURN (temp, - ACE_TCHAR[buffer_length], - -1); - - ACE_Auto_Basic_Array_Ptr buffer (temp); - - if ((errnum = ACE_TEXT_RegQueryValueEx (base_key, - t_name, - 0, - &type, - (BYTE *) buffer.get (), - &buffer_length)) != ERROR_SUCCESS) - { - errno = errnum; - return -1; - } - - value = buffer.get (); - return 0; -} - -int -ACE_Configuration_Win32Registry::get_integer_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - u_int& value) -{ - const ACE_TCHAR *t_name = temp_name (name); - if (validate_value_name (t_name)) - return -1; - - HKEY base_key; - if (load_key (key, base_key)) - return -1; - - int errnum; - DWORD length = sizeof (value); - DWORD type; - if ((errnum = ACE_TEXT_RegQueryValueEx (base_key, - t_name, - 0, - &type, - (BYTE *) &value, - &length)) != ERROR_SUCCESS) - { - errno = errnum; - return -1; - } - - if (type != REG_DWORD) - { - errno = ERROR_INVALID_DATATYPE; - return -1; - } - - return 0; -} - -int -ACE_Configuration_Win32Registry::get_binary_value ( - const ACE_Configuration_Section_Key &key, - const ACE_TCHAR *name, - void *&data, - size_t &length) -{ - const ACE_TCHAR *t_name = temp_name (name); - if (validate_value_name (t_name)) - return -1; - - HKEY base_key; - if (load_key (key, base_key)) - return -1; - - // Get the size of the binary data from windows - int errnum; - DWORD buffer_length = 0; - DWORD type; - if ((errnum = ACE_TEXT_RegQueryValueEx (base_key, - t_name, - 0, - &type, - (BYTE *) 0, - &buffer_length)) != ERROR_SUCCESS) - { - errno = errnum; - return -1; - } - - if (type != REG_BINARY) - { - errno = ERROR_INVALID_DATATYPE; - return -1; - } - - length = buffer_length; - - BYTE * the_data = 0; - ACE_NEW_RETURN (the_data, BYTE[length], -1); - ACE_Auto_Basic_Array_Ptr safe_data (the_data); - - if ((errnum = ACE_TEXT_RegQueryValueEx (base_key, - t_name, - 0, - &type, - the_data, - &buffer_length)) != ERROR_SUCCESS) - { - data = 0; - errno = errnum; - return -1; - } - - data = safe_data.release (); - - return 0; -} - -int -ACE_Configuration_Win32Registry::find_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - VALUETYPE& type_out) -{ - const ACE_TCHAR *t_name = temp_name (name); - if (validate_value_name (t_name)) - return -1; - - HKEY base_key; - if (load_key (key, base_key)) - return -1; - - DWORD buffer_length=0; - DWORD type; - int result=ACE_TEXT_RegQueryValueEx (base_key, - t_name, - 0, - &type, - 0, - &buffer_length); - if (result != ERROR_SUCCESS) - { - errno = result; - return -1; - } - - switch (type) - { - case REG_SZ: - type_out = STRING; - break; - case REG_DWORD: - type_out = INTEGER; - break; - case REG_BINARY: - type_out = BINARY; - break; - default: - return -1; // unknown type - } - - return 0; -} - -int -ACE_Configuration_Win32Registry::remove_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name) -{ - const ACE_TCHAR *t_name = temp_name (name); - if (validate_value_name (t_name)) - return -1; - - HKEY base_key; - if (load_key (key, base_key)) - return -1; - - int errnum; - if ((errnum = ACE_TEXT_RegDeleteValue (base_key, t_name)) != ERROR_SUCCESS) - { - errno = errnum; - return -1; - } - - return 0; -} - - -int -ACE_Configuration_Win32Registry::load_key (const ACE_Configuration_Section_Key& key, - HKEY& hKey) -{ - ACE_Section_Key_Win32* pKey = dynamic_cast (get_internal_key (key)); - if (!pKey) - return -1; - - hKey = pKey->hKey_; - return 0; -} - -HKEY -ACE_Configuration_Win32Registry::resolve_key (HKEY hKey, - const ACE_TCHAR* path, - bool create, - u_long security_access) -{ - HKEY result = 0; - // Make a copy of hKey - int errnum; -#if defined (ACE_HAS_WINCE) - if ((errnum = RegOpenKeyEx (hKey, 0, 0, 0, &result)) != ERROR_SUCCESS) -#else - if ((errnum = RegOpenKey (hKey, 0, &result)) != ERROR_SUCCESS) -#endif // ACE_HAS_WINCE - { - errno = errnum; - return 0; - } - - // recurse through the path - ACE_TCHAR *temp_path = 0; - ACE_NEW_RETURN (temp_path, - ACE_TCHAR[ACE_OS::strlen (path) + 1], - 0); - ACE_Auto_Basic_Array_Ptr pData (temp_path); - ACE_OS::strcpy (pData.get (), path); - ACE_Tokenizer parser (pData.get ()); - parser.delimiter_replace ('\\', '\0'); - parser.delimiter_replace ('/', '\0'); - - for (ACE_TCHAR *temp = parser.next (); - temp != 0; - temp = parser.next ()) - { - // Open the key - HKEY subkey; - -#if defined (ACE_HAS_WINCE) - if ((errnum = ACE_TEXT_RegOpenKeyEx (result, - temp, - 0, - 0, - &subkey)) != ERROR_SUCCESS) -#else - if ((errnum = ACE_TEXT_RegOpenKey (result, - temp, - &subkey)) != ERROR_SUCCESS) -#endif // ACE_HAS_WINCE - { - // try creating it - if (!create || (errnum = ACE_TEXT_RegCreateKeyEx (result, - temp, - 0, - 0, - 0, - security_access, - 0, - &subkey, - (PDWORD) 0 - )) !=ERROR_SUCCESS) - { - errno = errnum; - // error - ::RegCloseKey (result); - return 0; - } - } - // release our open key handle - ::RegCloseKey (result); - result = subkey; - } - - return result; -} - -#endif /* ACE_WIN32 && !ACE_LACKS_WIN32_REGISTRY */ - -/////////////////////////////////////////////////////////////// - -ACE_Configuration_Value_IntId::ACE_Configuration_Value_IntId (void) - : type_ (ACE_Configuration::INVALID), - length_ (0) -{ - this->data_.ptr_ = 0; -} - -ACE_Configuration_Value_IntId::ACE_Configuration_Value_IntId (ACE_TCHAR* string) - : type_ (ACE_Configuration::STRING), - length_ (0) -{ - this->data_.ptr_ = string; -} - -ACE_Configuration_Value_IntId::ACE_Configuration_Value_IntId (u_int integer) - : type_ (ACE_Configuration::INTEGER), - length_ (0) -{ - this->data_.int_ = integer; -} - -ACE_Configuration_Value_IntId::ACE_Configuration_Value_IntId (void* data, size_t length) - : type_ (ACE_Configuration::BINARY), - length_ (length) -{ - this->data_.ptr_ = data; -} - -ACE_Configuration_Value_IntId::ACE_Configuration_Value_IntId (const ACE_Configuration_Value_IntId& rhs) - : type_ (rhs.type_), - data_ (rhs.data_), - length_ (rhs.length_) -{ -} - -ACE_Configuration_Value_IntId::~ACE_Configuration_Value_IntId (void) -{ -} - -ACE_Configuration_Value_IntId& ACE_Configuration_Value_IntId::operator= (const ACE_Configuration_Value_IntId& rhs) -{ - if (this != &rhs) - { - type_ = rhs.type_; - data_ = rhs.data_; - length_ = rhs.length_; - } - return *this; -} - -void -ACE_Configuration_Value_IntId::free (ACE_Allocator *alloc) -{ - if (this->type_ == ACE_Configuration::STRING - || this->type_ == ACE_Configuration::BINARY) - alloc->free (data_.ptr_); - // Do nothing in other cases... -} - -ACE_Configuration_ExtId::ACE_Configuration_ExtId (void) - : name_ (0) -{ -} - -ACE_Configuration_ExtId::ACE_Configuration_ExtId (const ACE_TCHAR* name) - : name_ (name) -{ -} - -ACE_Configuration_ExtId::ACE_Configuration_ExtId (const ACE_Configuration_ExtId& rhs) - : name_ (rhs.name_) -{ -} - -ACE_Configuration_ExtId::~ACE_Configuration_ExtId (void) -{ -} - -ACE_Configuration_ExtId& ACE_Configuration_ExtId::operator= (const ACE_Configuration_ExtId& rhs) -{ - if (this != &rhs) - name_ = rhs.name_; - - return *this; -} - -bool -ACE_Configuration_ExtId::operator== (const ACE_Configuration_ExtId& rhs) const -{ - return (ACE_OS::strcasecmp (name_, rhs.name_) == 0); -} - -bool -ACE_Configuration_ExtId::operator!= (const ACE_Configuration_ExtId& rhs) const -{ - return !this->operator== (rhs); -} - -u_long -ACE_Configuration_ExtId::hash (void) const -{ - ACE_TString temp (name_, 0, false); - return temp.hash (); -} - -void -ACE_Configuration_ExtId::free (ACE_Allocator *alloc) -{ - alloc->free ((void *) (name_)); -} - -/////////////////////////////////////////////////////////////////////// - -ACE_Configuration_Section_IntId::ACE_Configuration_Section_IntId (void) - : value_hash_map_ (0), - section_hash_map_ (0) -{ -} - -ACE_Configuration_Section_IntId::ACE_Configuration_Section_IntId (VALUE_MAP* value_hash_map, SUBSECTION_MAP* section_hash_map) - : value_hash_map_ (value_hash_map), - section_hash_map_ (section_hash_map) -{ -} - -ACE_Configuration_Section_IntId::ACE_Configuration_Section_IntId (const ACE_Configuration_Section_IntId& rhs) - : value_hash_map_ (rhs.value_hash_map_), - section_hash_map_ (rhs.section_hash_map_) -{ - -} - -ACE_Configuration_Section_IntId::~ACE_Configuration_Section_IntId () -{ -} - -ACE_Configuration_Section_IntId& -ACE_Configuration_Section_IntId::operator= (const ACE_Configuration_Section_IntId& rhs) -{ - if (this != &rhs) - { - value_hash_map_ = rhs.value_hash_map_; - section_hash_map_ = rhs.section_hash_map_; - } - return *this; -} - -void -ACE_Configuration_Section_IntId::free (ACE_Allocator *alloc) -{ - alloc->free ((void *) (value_hash_map_)); - alloc->free ((void *) (section_hash_map_)); -} - -ACE_Configuration_Section_Key_Heap::ACE_Configuration_Section_Key_Heap (const ACE_TCHAR* path) - : path_ (0), - value_iter_ (0), - section_iter_ (0) -{ - path_ = ACE_OS::strdup (path); -} - -ACE_Configuration_Section_Key_Heap::~ACE_Configuration_Section_Key_Heap () -{ - delete value_iter_; - delete section_iter_; -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (path_); -#else - ACE_OS::free (path_); -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Configuration_Section_Key_Heap) - -////////////////////////////////////////////////////////////////////////////// - -ACE_Configuration_Heap::ACE_Configuration_Heap (void) - : allocator_ (0), - index_ (0), - default_map_size_ (0) -{ - ACE_Configuration_Section_Key_Heap *temp = 0; - - ACE_NEW (temp, ACE_Configuration_Section_Key_Heap (ACE_TEXT (""))); - root_ = ACE_Configuration_Section_Key (temp); -} - -ACE_Configuration_Heap::~ACE_Configuration_Heap (void) -{ - if (allocator_) - allocator_->sync (); - - delete allocator_; -} - -int -ACE_Configuration_Heap::open (size_t default_map_size) -{ - if (this->allocator_ != 0) - { - errno = EBUSY; - return -1; - } - - default_map_size_ = default_map_size; - // Create the allocator with the appropriate options. - // The name used for the lock is the same as one used - // for the file. - ACE_NEW_RETURN (this->allocator_, - HEAP_ALLOCATOR (), - -1); - return create_index (); -} - - -int -ACE_Configuration_Heap::open (const ACE_TCHAR* file_name, - void* base_address, - size_t default_map_size) -{ - if (this->allocator_ != 0) - { - errno = EBUSY; - return -1; - } - - default_map_size_ = default_map_size; - - // Make sure that the file name is of the legal length. - if (ACE_OS::strlen (file_name) >= MAXNAMELEN + MAXPATHLEN) - { - errno = ENAMETOOLONG; - return -1; - } - - ACE_MMAP_Memory_Pool::OPTIONS options (base_address); - - // Create the allocator with the appropriate options. The name used - // for the lock is the same as one used for the file. - ACE_NEW_RETURN (this->allocator_, - PERSISTENT_ALLOCATOR (file_name, - file_name, - &options), - -1); - -#if !defined (ACE_LACKS_ACCESS) - // Now check if the backing store has been created successfully. - if (ACE_OS::access (file_name, F_OK) != 0) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("create_index\n")), - -1); -#endif /* ACE_LACKS_ACCESS */ - - return create_index (); -} - -int -ACE_Configuration_Heap::create_index (void) -{ - void *section_index = 0; - - // This is the easy case since if we find hash table in the - // memory-mapped file we know it's already initialized. - if (this->allocator_->find (ACE_CONFIG_SECTION_INDEX, section_index) == 0) - this->index_ = (SECTION_MAP *) section_index; - - // Create a new (because we've just created a new - // memory-mapped file). - else - { - size_t index_size = sizeof (SECTION_MAP); - section_index = this->allocator_->malloc (index_size); - - if (section_index == 0 - || create_index_helper (section_index) == -1 - || this->allocator_->bind (ACE_CONFIG_SECTION_INDEX, - section_index) == -1) - { - // Attempt to clean up. - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("create_index failed\n"))); - this->allocator_->remove (); - return -1; - } - // Add the root section - return new_section (ACE_TEXT (""), root_); - } - return 0; -} - -int -ACE_Configuration_Heap::create_index_helper (void *buffer) -{ - ACE_ASSERT (this->allocator_); - this->index_ = new (buffer) SECTION_MAP (this->allocator_); - return 0; -} - -int -ACE_Configuration_Heap::load_key (const ACE_Configuration_Section_Key& key, - ACE_TString& name) -{ - ACE_ASSERT (this->allocator_); - ACE_Configuration_Section_Key_Heap* pKey = - dynamic_cast (get_internal_key (key)); - - if (!pKey) - { - return -1; - } - - ACE_TString temp (pKey->path_, 0, false); - name.assign_nocopy (temp); - return 0; -} - - -int -ACE_Configuration_Heap::add_section (const ACE_Configuration_Section_Key& base, - const ACE_TCHAR* sub_section, - ACE_Configuration_Section_Key& result) -{ - ACE_ASSERT (this->allocator_); - ACE_TString section; - if (load_key (base, section)) - return -1; - - // Find the base section - ACE_Configuration_ExtId ExtId (section.fast_rep ()); - ACE_Configuration_Section_IntId IntId; - if (index_->find (ExtId, IntId, allocator_)) - return -1; - - // See if this section already exists - ACE_Configuration_ExtId SubSectionExtId (sub_section); - int ignored = 0; - - if (!IntId.section_hash_map_->find (SubSectionExtId, ignored, allocator_)) - { - // already exists! - errno = EEXIST; - return -1; - } - - // Create the new section name - // only prepend a separater if were not at the root - if (section.length ()) - section += ACE_TEXT ("\\"); - - section += sub_section; - - // Add it to the base section - ACE_TCHAR* pers_name = (ACE_TCHAR *) allocator_->malloc ((ACE_OS::strlen (sub_section) + 1) * sizeof (ACE_TCHAR)); - ACE_OS::strcpy (pers_name, sub_section); - ACE_Configuration_ExtId SSExtId (pers_name); - if (IntId.section_hash_map_->bind (SSExtId, ignored, allocator_)) - { - allocator_->free (pers_name); - return -1; - } - return (new_section (section, result)); -} - -int -ACE_Configuration_Heap::new_section (const ACE_TString& section, - ACE_Configuration_Section_Key& result) -{ - ACE_ASSERT (this->allocator_); - // Create a new section and add it to the global list - - // Allocate memory for items to be stored in the table. - size_t section_len = section.length () + 1; - ACE_TCHAR *ptr = (ACE_TCHAR*) this->allocator_->malloc (section_len * sizeof (ACE_TCHAR)); - - int return_value = -1; - - if (ptr == 0) - return -1; - else - { - // Populate memory with data. - ACE_OS::strcpy (ptr, section.fast_rep ()); - - void *value_hash_map = 0; - size_t map_size = sizeof (VALUE_MAP); - value_hash_map = this->allocator_->malloc (map_size); - - // If allocation failed ... - if (value_hash_map == 0) - return -1; - - // Initialize allocated hash map through placement new. - if (value_open_helper (default_map_size_, value_hash_map ) == -1) - { - this->allocator_->free (value_hash_map ); - return -1; - } - - // create the section map - void* section_hash_map = 0; - map_size = sizeof (SUBSECTION_MAP); - section_hash_map = this->allocator_->malloc (map_size); - - // If allocation failed - if (section_hash_map == 0) - return -1; - - // initialize allocated hash map through placement new - if (section_open_helper (default_map_size_, section_hash_map) == -1) - { - this->allocator_->free (value_hash_map ); - this->allocator_->free (section_hash_map); - return -1; - } - - ACE_Configuration_ExtId name (ptr); - ACE_Configuration_Section_IntId entry ((VALUE_MAP*) value_hash_map, - (SUBSECTION_MAP*) section_hash_map); - - // Do a normal bind. This will fail if there's already an - // entry with the same name. - return_value = this->index_->bind (name, entry, this->allocator_); - - if (return_value == 1 /* Entry already existed so bind failed. */ - || return_value == -1 /* Unable to bind for other reasons. */) - { - // Free our dynamically allocated memory. - this->allocator_->free (static_cast (ptr)); - return return_value; - } - - // If bind () succeed, it will automatically sync - // up the map manager entry. However, we must sync up our - // name/value memory. - this->allocator_->sync (ptr, section_len); - } - - // set the result - ACE_Configuration_Section_Key_Heap *temp; - ACE_NEW_RETURN (temp, - ACE_Configuration_Section_Key_Heap (ptr), - -1); - result = ACE_Configuration_Section_Key (temp); - return return_value; -} - -int -ACE_Configuration_Heap::value_open_helper (size_t hash_table_size, - void *buffer) -{ - ACE_ASSERT (this->allocator_); - new (buffer) VALUE_MAP (hash_table_size, this->allocator_); - return 0; -} - -int -ACE_Configuration_Heap::section_open_helper (size_t hash_table_size, - void *buffer) -{ - ACE_ASSERT (this->allocator_); - new (buffer) SUBSECTION_MAP (hash_table_size, this->allocator_); - return 0; -} - -int -ACE_Configuration_Heap::open_section (const ACE_Configuration_Section_Key& base, - const ACE_TCHAR* sub_section, - bool create, - ACE_Configuration_Section_Key& result) -{ - ACE_ASSERT (this->allocator_); - if (validate_name (sub_section, 1)) // 1 == allow_path - return -1; - - result = base; - - for (const ACE_TCHAR* separator; - (separator = ACE_OS::strchr (sub_section, ACE_TEXT ('\\'))) != 0; - ) - { - ACE_TString simple_section (sub_section, separator - sub_section); - int ret_val = - open_simple_section (result, simple_section.c_str (), create, result); - if (ret_val) - return ret_val; - sub_section = separator + 1; - } - - return open_simple_section (result, sub_section, create, result); -} - -int -ACE_Configuration_Heap::open_simple_section (const ACE_Configuration_Section_Key& base, - const ACE_TCHAR* sub_section, - bool create, - ACE_Configuration_Section_Key& result) -{ - ACE_TString section (0, 0, false); - - if (load_key (base, section)) - { - return -1; - } - - // Only add the \\ if were not at the root - if (section.length ()) - { - section += ACE_TEXT ("\\"); - } - - section += sub_section; - - // resolve the section - ACE_Configuration_ExtId ExtId (section.fast_rep ()); - ACE_Configuration_Section_IntId IntId; - - if (index_->find (ExtId, IntId, allocator_)) - { - if (!create) - { - errno = ENOENT; - return -1; - } - - return add_section (base, sub_section, result); - } - - ACE_Configuration_Section_Key_Heap *temp; - ACE_NEW_RETURN (temp, - ACE_Configuration_Section_Key_Heap (section.fast_rep ()), - -1); - result = ACE_Configuration_Section_Key (temp); - return 0; -} - -int -ACE_Configuration_Heap::remove_section (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* sub_section, - bool recursive) -{ - ACE_ASSERT (this->allocator_); - if (validate_name (sub_section)) - return -1; - - ACE_TString section; - if (load_key (key, section)) - return -1; - - // Find this key - ACE_Configuration_ExtId ParentExtId (section.fast_rep ()); - ACE_Configuration_Section_IntId ParentIntId; - if (index_->find (ParentExtId, ParentIntId, allocator_)) - return -1;// no parent key - - // Find this subkey - if (section.length ()) - section += ACE_TEXT ("\\"); - - section += sub_section; - ACE_Configuration_ExtId SectionExtId (section.fast_rep ()); - SECTION_HASH::ENTRY* section_entry = 0; - SECTION_HASH* hashmap = index_; - if (hashmap->find (SectionExtId, section_entry)) - return -1; - - if (recursive) - { - ACE_Configuration_Section_Key recursive_section; - if (open_section (key, sub_section, 0, recursive_section)) - return -1; - - int index = 0; - ACE_TString name; - while (!enumerate_sections (recursive_section, index, name)) - { - if (remove_section (recursive_section, name.fast_rep (), true)) - return -1; - - ++index; - } - } - - // Now make sure we dont have any subkeys - if (section_entry->int_id_.section_hash_map_->current_size ()) - { - errno = ENOTEMPTY; - return -1; - } - - // Now remove subkey from parent key - ACE_Configuration_ExtId SubSExtId (sub_section); - SUBSECTION_HASH::ENTRY* subsection_entry = 0; - if (((SUBSECTION_HASH*)ParentIntId.section_hash_map_)-> - find (SubSExtId, subsection_entry)) - return -1; - - if (ParentIntId.section_hash_map_->unbind (SubSExtId, allocator_)) - return -1; - - subsection_entry->ext_id_.free (allocator_); - - // Remember the pointers so we can free them after we unbind - ACE_Configuration_ExtId ExtIdToFree (section_entry->ext_id_); - ACE_Configuration_Section_IntId IntIdToFree (section_entry->int_id_); - - // iterate over all values and free memory - VALUE_HASH* value_hash_map = section_entry->int_id_.value_hash_map_; - VALUE_HASH::ITERATOR value_iter = value_hash_map->begin (); - while (!value_iter.done ()) - { - VALUE_HASH::ENTRY* value_entry = 0; - if (!value_iter.next (value_entry)) - return 1; - - value_entry->ext_id_.free (allocator_); - value_entry->int_id_.free (allocator_); - - value_iter.advance (); - } - - // remove it - if (index_->unbind (SectionExtId, allocator_)) - return -1; - - value_hash_map->close (); - section_entry->int_id_.section_hash_map_->close (allocator_); - - // Free the memory - ExtIdToFree.free (allocator_); - IntIdToFree.free (allocator_); - - return 0; -} - -int -ACE_Configuration_Heap::enumerate_values (const ACE_Configuration_Section_Key& key, - int index, - ACE_TString& name, - VALUETYPE& type) -{ - ACE_ASSERT (this->allocator_); - ACE_Configuration_Section_Key_Heap* pKey = - dynamic_cast (get_internal_key (key)); - if (!pKey) - return -1; - - name = pKey->path_; - - // resolve the section - ACE_Configuration_ExtId ExtId (pKey->path_); - ACE_Configuration_Section_IntId IntId; - if (index_->find (ExtId, IntId, allocator_)) - return -1; - - // Handle iterator resets - if (index == 0) - { - ACE_Hash_Map_Manager_Ex, - ACE_Equal_To, - ACE_Null_Mutex>* hash_map = IntId.value_hash_map_; - delete pKey->value_iter_; - - ACE_NEW_RETURN (pKey->value_iter_, - VALUE_HASH::ITERATOR (hash_map->begin ()), - -1); - } - - // Get the next entry - ACE_Hash_Map_Entry* entry = 0; - - if (!pKey->value_iter_->next (entry)) - return 1; - - // Return the value of the iterator and advance it - name = entry->ext_id_.name_; - type = entry->int_id_.type_; - pKey->value_iter_->advance (); - - return 0; -} - -int -ACE_Configuration_Heap::enumerate_sections (const ACE_Configuration_Section_Key& key, - int index, - ACE_TString& name) -{ - ACE_ASSERT (this->allocator_); - // cast to a heap section key - ACE_Configuration_Section_Key_Heap* pKey = - dynamic_cast (get_internal_key (key)); - if (!pKey) - return -1; // not a heap key! - - // resolve the section - ACE_Configuration_ExtId ExtId (pKey->path_); - ACE_Configuration_Section_IntId IntId; - if (index_->find (ExtId, IntId, allocator_)) - return -1; // unknown section - - // Handle iterator resets - if (index == 0) - { - if (pKey->section_iter_) - delete pKey->section_iter_; - - ACE_NEW_RETURN (pKey->section_iter_, - SUBSECTION_HASH::ITERATOR (IntId.section_hash_map_->begin ()), - -1); - } - - // Get the next entry - ACE_Hash_Map_Entry* entry = 0; - if (!pKey->section_iter_->next (entry)) - return 1; - - // Return the value of the iterator and advance it - pKey->section_iter_->advance (); - name = entry->ext_id_.name_; - - return 0; -} - -int -ACE_Configuration_Heap::set_string_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - const ACE_TString& value) -{ - ACE_ASSERT (this->allocator_); - const ACE_TCHAR *t_name = name ? name : &this->NULL_String_; - if (validate_value_name (t_name)) - return -1; - - ACE_TString section; - if (load_key (key, section)) - return -1; - - ACE_Configuration_ExtId section_ext (section.fast_rep ()); - ACE_Configuration_Section_IntId section_int; - if (index_->find (section_ext, section_int, allocator_)) - return -1; - - // Get the entry for this item (if it exists) - VALUE_HASH::ENTRY* entry = 0; - ACE_Configuration_ExtId item_name (t_name); - if (section_int.value_hash_map_->VALUE_HASH::find (item_name, entry) == 0) - { - // found item, replace it - // Free the old value - entry->int_id_.free (allocator_); - // Allocate the new value in this heap - ACE_TCHAR* pers_value = - (ACE_TCHAR *) allocator_->malloc ((value.length () + 1) * sizeof (ACE_TCHAR)); - ACE_OS::strcpy (pers_value, value.fast_rep ()); - ACE_Configuration_Value_IntId new_value_int (pers_value); - entry->int_id_ = new_value_int; - } - else - { - // it doesn't exist, bind it - ACE_TCHAR* pers_name = - (ACE_TCHAR *) allocator_->malloc ((ACE_OS::strlen (t_name) + 1) * sizeof (ACE_TCHAR)); - ACE_OS::strcpy (pers_name, t_name); - ACE_TCHAR* pers_value = - (ACE_TCHAR *) allocator_->malloc ((value.length () + 1) * sizeof (ACE_TCHAR)); - ACE_OS::strcpy (pers_value, value.fast_rep ()); - ACE_Configuration_ExtId new_item_name (pers_name); - ACE_Configuration_Value_IntId item_value (pers_value); - if (section_int.value_hash_map_->bind (new_item_name, item_value, allocator_)) - { - allocator_->free (pers_value); - allocator_->free (pers_name); - return -1; - } - return 0; - } - - return 0; -} - -int -ACE_Configuration_Heap::set_integer_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - u_int value) -{ - ACE_ASSERT (this->allocator_); - const ACE_TCHAR *t_name = name ? name : &this->NULL_String_; - if (validate_value_name (t_name)) - return -1; - - // Get the section name from the key - ACE_TString section; - if (load_key (key, section)) - return -1; - - // Find this section - ACE_Configuration_ExtId section_ext (section.fast_rep ()); - ACE_Configuration_Section_IntId section_int; - if (index_->find (section_ext, section_int, allocator_)) - return -1; // section does not exist - - // Get the entry for this item (if it exists) - VALUE_HASH::ENTRY* entry = 0; - ACE_Configuration_ExtId item_name (t_name); - if (section_int.value_hash_map_->VALUE_HASH::find (item_name, entry) == 0) - { - // found item, replace it - ACE_Configuration_Value_IntId new_value_int (value); - entry->int_id_ = new_value_int; - } - else - { - // it doesn't exist, bind it - ACE_TCHAR* pers_name = - (ACE_TCHAR *) allocator_->malloc ((ACE_OS::strlen (t_name) + 1) * sizeof (ACE_TCHAR)); - ACE_OS::strcpy (pers_name, t_name); - ACE_Configuration_ExtId item_name (pers_name); - ACE_Configuration_Value_IntId item_value (value); - if (section_int.value_hash_map_->bind (item_name, item_value, allocator_)) - { - allocator_->free (pers_name); - return -1; - } - return 0; - } - - return 0; -} - -int -ACE_Configuration_Heap::set_binary_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - const void* data, - size_t length) -{ - ACE_ASSERT (this->allocator_); - const ACE_TCHAR *t_name = name ? name : &this->NULL_String_; - if (validate_value_name (t_name)) - return -1; - - // Get the section name from the key - ACE_TString section; - if (load_key (key, section)) - return -1; - - // Find this section - ACE_Configuration_ExtId section_ext (section.fast_rep ()); - ACE_Configuration_Section_IntId section_int; - if (index_->find (section_ext, section_int, allocator_)) - return -1; // section does not exist - - // Get the entry for this item (if it exists) - VALUE_HASH::ENTRY* entry = 0; - ACE_Configuration_ExtId item_name (t_name); - if (section_int.value_hash_map_->VALUE_HASH::find (item_name, entry) == 0) - { - // found item, replace it - // Free the old value - entry->int_id_.free (allocator_); - // Allocate the new value in this heap - ACE_TCHAR* pers_value = (ACE_TCHAR *) allocator_->malloc (length); - ACE_OS::memcpy (pers_value, data, length); - ACE_Configuration_Value_IntId new_value_int (pers_value, length); - entry->int_id_ = new_value_int; - } - else - { - // it doesn't exist, bind it - ACE_TCHAR* pers_name = - (ACE_TCHAR *) allocator_->malloc ((ACE_OS::strlen (t_name) + 1) * sizeof (ACE_TCHAR)); - ACE_OS::strcpy (pers_name, t_name); - ACE_TCHAR* pers_value = (ACE_TCHAR *) allocator_->malloc (length); - ACE_OS::memcpy (pers_value, data, length); - ACE_Configuration_ExtId item_name (pers_name); - ACE_Configuration_Value_IntId item_value (pers_value, length); - if (section_int.value_hash_map_->bind (item_name, item_value, allocator_)) - { - allocator_->free (pers_value); - allocator_->free (pers_name); - return -1; - } - return 0; - } - - return 0; -} - -int -ACE_Configuration_Heap::get_string_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - ACE_TString& value) -{ - ACE_ASSERT (this->allocator_); - const ACE_TCHAR *t_name = name ? name : &this->NULL_String_; - if (validate_value_name (t_name)) - return -1; - - // Get the section name from the key - ACE_TString section; - if (load_key (key, section)) - return -1; - - // Find this section - ACE_Configuration_ExtId ExtId (section.fast_rep ()); - ACE_Configuration_Section_IntId IntId; - if (index_->find (ExtId, IntId, allocator_)) - return -1; // section does not exist - - // See if it exists first - ACE_Configuration_ExtId VExtId (t_name); - ACE_Configuration_Value_IntId VIntId; - if (IntId.value_hash_map_->find (VExtId, VIntId, allocator_)) - return -1; // unknown value - - // Check type - if (VIntId.type_ != ACE_Configuration::STRING) - { - errno = ENOENT; - return -1; - } - - // everythings ok, return the data - value = static_cast (VIntId.data_.ptr_); - return 0; -} - -int -ACE_Configuration_Heap::get_integer_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - u_int& value) -{ - ACE_ASSERT (this->allocator_); - - const ACE_TCHAR *t_name = name ? name : &this->NULL_String_; - if (validate_value_name (t_name)) - return -1; - - // Get the section name from the key - ACE_TString section (0, 0, false); - - if (this->load_key (key, section) != 0) - { - return -1; - } - - // Find this section - ACE_Configuration_ExtId ExtId (section.fast_rep ()); - ACE_Configuration_Section_IntId IntId; - - if (index_->find (ExtId, IntId, allocator_) != 0) - { - return -1; // section does not exist - } - - - // See if it exists first - ACE_Configuration_ExtId VExtId (t_name); - ACE_Configuration_Value_IntId VIntId; - - if (IntId.value_hash_map_->find (VExtId, VIntId, allocator_) != 0) - { - return -1; // unknown value - } - - // Check type - if (VIntId.type_ != ACE_Configuration::INTEGER) - { - errno = ENOENT; - return -1; - } - - // Everythings ok, return the data - value = VIntId.data_.int_; - return 0; -} - -int -ACE_Configuration_Heap::get_binary_value ( - const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - void*& data, - size_t& length) -{ - ACE_ASSERT (this->allocator_); - const ACE_TCHAR *t_name = name ? name : &this->NULL_String_; - if (validate_value_name (t_name)) - return -1; - - // Get the section name from the key - ACE_TString section; - if (load_key (key, section)) - return -1; - - // Find this section - ACE_Configuration_ExtId ExtId (section.fast_rep ()); - ACE_Configuration_Section_IntId IntId; - if (index_->find (ExtId, IntId, allocator_)) - return -1; // section does not exist - - ACE_Configuration_ExtId VExtId (t_name); - ACE_Configuration_Value_IntId VIntId; - // See if it exists first - if (IntId.value_hash_map_->find (VExtId, VIntId, allocator_)) - return -1; // unknown value - - // Check type - if (VIntId.type_ != ACE_Configuration::BINARY) - { - errno = ENOENT; - return -1; - } - - // Make a copy -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (data, static_cast (ACE_Allocator::instance()->malloc(sizeof(char) * VIntId.length_)), -1); -#else - ACE_NEW_RETURN (data, char[VIntId.length_], -1); -#endif /* ACE_HAS_ALLOC_HOOKS */ - ACE_OS::memcpy (data, VIntId.data_.ptr_, VIntId.length_); - length = VIntId.length_; - return 0; -} - -int -ACE_Configuration_Heap::find_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - VALUETYPE& type_out) -{ - ACE_ASSERT (this->allocator_); - const ACE_TCHAR *t_name = name ? name : &this->NULL_String_; - if (validate_value_name (t_name)) - return -1; - - // Get the section name from the key - ACE_TString section; - if (load_key (key, section)) - return -1; - - // Find this section - ACE_Configuration_ExtId ExtId (section.fast_rep ()); - ACE_Configuration_Section_IntId IntId; - if (index_->find (ExtId, IntId, allocator_)) - return -1; // section does not exist - - // Find it - ACE_Configuration_ExtId ValueExtId (t_name); - VALUE_HASH::ENTRY* value_entry = 0; - if (((VALUE_HASH *) IntId.value_hash_map_)->find (ValueExtId, value_entry)) - return -1; // value does not exist - - type_out = value_entry->int_id_.type_; - return 0; -} - -int -ACE_Configuration_Heap::remove_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name) -{ - ACE_ASSERT (this->allocator_); - const ACE_TCHAR *t_name = name ? name : &this->NULL_String_; - if (validate_value_name (t_name)) - return -1; - - // Get the section name from the key - ACE_TString section; - if (load_key (key, section)) - return -1; - - // Find this section - ACE_Configuration_ExtId ExtId (section.fast_rep ()); - ACE_Configuration_Section_IntId IntId; - if (index_->find (ExtId, IntId, allocator_)) - return -1; // section does not exist - - // Find it - ACE_Configuration_ExtId ValueExtId (t_name); - VALUE_HASH::ENTRY* value_entry = 0; - if (((VALUE_HASH *) IntId.value_hash_map_)->find (ValueExtId, value_entry)) - return -1; - - // free it - value_entry->ext_id_.free (allocator_); - value_entry->int_id_.free (allocator_); - - // Unbind it - if (IntId.value_hash_map_->unbind (ValueExtId, allocator_)) - return -1; - - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Configuration.h b/deps/acelite/ace/Configuration.h deleted file mode 100644 index 7e89c4de4..000000000 --- a/deps/acelite/ace/Configuration.h +++ /dev/null @@ -1,903 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Configuration.h - * - * @author Chris Hafey - * - * The ACE configuration API provides a portable abstraction for - * program configuration similar to the Microsoft Windows registry. - * The API supports a tree based hierarchy of configuration sections. Each - * section contains other sections or values. Values may contain string, - * unsigned integer and binary data. - * - * @note These classes are not thread safe, if multiple threads use these - * classes, you are responsible for serializing access. - * - * For examples of using this class, see: - * -# The test code in ACE_wrappers/test - * -# wxConfigViewer, a Windows like Registry Editor for ACE_Configuration - * -# TAO's IFR, it makes extensive use of ACE_Configuration - * - * @todo Templatize this class with an ACE_LOCK to provide thread safety - */ -//============================================================================= - -#ifndef ACE_CONFIGURATION_H -#define ACE_CONFIGURATION_H -#include /**/ "ace/pre.h" - -#include "ace/SStringfwd.h" -#include "ace/Hash_Map_With_Allocator_T.h" -#include "ace/Malloc_T.h" -#include "ace/MMAP_Memory_Pool.h" -#include "ace/Local_Memory_Pool.h" -#include "ace/Synch_Traits.h" - - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -// configurable parameters - -#if !defined (ACE_CONFIG_SECTION_INDEX) -# define ACE_CONFIG_SECTION_INDEX "Config_Section_Index" -#endif /* ! ACE_CONFIG_SECTION_INDEX */ - -#if !defined (ACE_DEFAULT_CONFIG_SECTION_SIZE) -#define ACE_DEFAULT_CONFIG_SECTION_SIZE 16 -#endif /* ACE_DEFAULT_CONFIG_SECTION_SIZE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Section_Key_Internal - * - * @internal - * - * @brief A base class for internal handles to section keys for - * configuration implementations - * - * Implementations subclass this base class to represent a - * section key. - */ -class ACE_Export ACE_Section_Key_Internal -{ -public: - /// Virtual destructor, make sure descendants are virtual! - virtual ~ACE_Section_Key_Internal (void); - - /// Increment reference count - virtual int add_ref (void); - - /// Decrement reference count. Will delete this if count gets to 0 - virtual int dec_ref (void); -protected: - ACE_Section_Key_Internal (void); - ACE_Section_Key_Internal (const ACE_Section_Key_Internal& rhs); - ACE_Section_Key_Internal& operator= (ACE_Section_Key_Internal& rhs); - - u_int ref_count_; -}; - -/** - * @class ACE_Configuration_Section_Key - * - * @brief Reference counted wrapper for ACE_Section_Key_Internal. - * - * Reference counted wrapper class for the abstract internal - * section key. A user gets one of these to represent a section - * in the configuration database. - */ -class ACE_Export ACE_Configuration_Section_Key -{ - friend class ACE_Configuration; -public: - /// Default constructor. - ACE_Configuration_Section_Key (void); - - /// Constructor that initializes to a pointer to a concrete internal key. - /** - * @param key The section key to reference. Calls add_ref() with @a key. - */ - explicit ACE_Configuration_Section_Key (ACE_Section_Key_Internal *key); - - /// Copy constructor, increments the reference count on the key. - ACE_Configuration_Section_Key (const ACE_Configuration_Section_Key &rhs); - - /// Destructor, decrements reference count on the referenced key. - ~ACE_Configuration_Section_Key (void); - - /// Assignment operator, increments reference count for this object - /// and decrements it on @a rhs. - ACE_Configuration_Section_Key & - operator= (const ACE_Configuration_Section_Key &rhs); -private: - ACE_Section_Key_Internal *key_; -}; - -/** - * @class ACE_Configuration - * - * @internal - * - * @brief Base class for configuration databases - * - * This class provides an interface for configuration databases. A concrete - * class is required that implements the interface. - * - * @sa ACE_Configuration_Heap - * @sa ACE_Configuration_Win32Registry - */ -class ACE_Export ACE_Configuration -{ -public: - /// Enumeration for the various types of values we can store. - enum VALUETYPE - { - STRING, - INTEGER, - BINARY, - INVALID - }; - - /// Destructor - virtual ~ACE_Configuration (void); - - /// Obtain a reference to the root section of this configuration. - /* - * @return Reference to the configuration's root section. Note that - * it is a const reference. - */ - virtual const ACE_Configuration_Section_Key& root_section (void) const; - - /** - * Opens a named section in an existing section. - * - * @param base Existing section in which to open the named section. - * @param sub_section Name of the section to open. - * @param create If false, the named section must exist, otherwise - * the named section will be created if it does not exist. - * @param result Reference; receives the section key for the new - * section. - * - * @retval 0 for success. - * @retval -1 for error; ACE_OS::last_error() retrieves error code. - */ - virtual int open_section (const ACE_Configuration_Section_Key &base, - const ACE_TCHAR *sub_section, - bool create, - ACE_Configuration_Section_Key& result) = 0; - - /// Removes a named section. - /** - * @param key Section key to remove the named section from. - * @param sub_section Name of the section to remove. - * @param recursive If true, any subkeys below @a sub_section are - * removed as well. - * - * @retval 0 for success. - * @retval -1 for error; ACE_OS::last_error() retrieves error code. - */ - virtual int remove_section (const ACE_Configuration_Section_Key &key, - const ACE_TCHAR *sub_section, - bool recursive) = 0; - - /** - * Enumerates through the values in a section. - * - * @param key Section key to iterate through. - * @param index Iteration position. Must be zero on the first call to - * iterate through @a key. Increment @a index by one on each - * successive call to this method. - * @param name Receives the value's name. - * @param type Receives the value's data type. - * - * @note You may not delete or add values while enumerating. If the - * section is modified during enumeration, results are undefined; - * you must restart the enumeration from index 0. - * - * @retval 0 for success, @a name and @a type are valid. - * @retval 1 there are no more values in the section. - * @retval -1 for error; ACE_OS::last_error() retrieves error code. - */ - virtual int enumerate_values (const ACE_Configuration_Section_Key& key, - int index, - ACE_TString& name, - VALUETYPE& type) = 0; - - /** - * Enumerates through the subsections in a section. - * - * @param key Section key to iterate through. - * @param index Iteration position. Must be zero on the first call to - * iterate through @a key. Increment @a index by one on each - * successive call to this method. - * @param name Receives the subsection's name. - * - * @note You may not modify the @a key section while enumerating. If the - * section is modified during enumeration, results are undefined; - * you must restart the enumeration from index 0. - * - * @retval 0 for success, @a name has a valid name. - * @retval 1 there are no more subsections in the section. - * @retval -1 for error; ACE_OS::last_error() retrieves error code. - */ - virtual int enumerate_sections (const ACE_Configuration_Section_Key& key, - int index, ACE_TString& name) = 0; - - /// Sets a string-typed value. - /** - * @param key Configuration section to set the value in. - * @param name Name of the configuration value to set. If a value with - * the specified name exists, it is replaced. - * @param value The string to set the configuration value to. - * - * @retval 0 for success. - * @retval -1 for error; ACE_OS::last_error() retrieves error code. - */ - virtual int set_string_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - const ACE_TString& value) = 0; - - /// Sets a integer-typed value. - /** - * @param key Configuration section to set the value in. - * @param name Name of the configuration value to set. If a value with - * the specified name exists, it is replaced. - * @param value The integer to set the configuration value to. - * - * @retval 0 for success. - * @retval -1 for error; ACE_OS::last_error() retrieves error code. - */ - virtual int set_integer_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - u_int value) = 0; - - /// Sets a binary-typed value. - /** - * @param key Configuration section to set the value in. - * @param name Name of the configuration value to set. If a value with - * the specified name exists, it is replaced. - * @param data Pointer to the binary data for the value. - * @param length Number of bytes for the new value. - * - * @retval 0 for success. - * @retval -1 for error; ACE_OS::last_error() retrieves error code. - */ - virtual int set_binary_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - const void* data, - size_t length) = 0; - - /// Gets a string-typed value. - /** - * @param key Configuration section to get the value from. - * @param name Name of the configuration value to get. - * @param value Receives the configuration value if it exists and - * has type STRING. - * - * @retval 0 for success. - * @retval -1 for error; ACE_OS::last_error() retrieves error code. - */ - virtual int get_string_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - ACE_TString& value) = 0; - - /// Gets an integer-typed value. - /** - * @param key Configuration section to get the value from. - * @param name Name of the configuration value to get. - * @param value Receives the configuration value if it exists and - * has type INTEGER. - * - * @retval 0 for success. - * @retval -1 for error; ACE_OS::last_error() retrieves error code. - */ - virtual int get_integer_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - u_int& value) = 0; - - /// Gets a binary-typed value. - /** - * @param key Configuration section to get the value from. - * @param name Name of the configuration value to get. - * @param data Receives a pointer to memory holding the binary data - * for the value. This method allocates the memory pointed - * to using operator new[]. The caller is responsible for - * freeing the memory using operator delete[]. - * @param length Receives the number of bytes in the value. - * - * @retval 0 for success; caller is responsible for freeing the - * returned memory. - * @retval -1 for error; ACE_OS::last_error() retrieves error code. - */ - virtual int get_binary_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - void*& data, - size_t& length) = 0; - - /** - * Retrieves the type of a named configuration value. - * - * @param key Configuration section to look up the name in. - * @param name Name of the configuration value to get the type of. - * @param type Receives the data type of the named value, if it exists. - * - * @retval 0 for success. - * @retval -1 for error; ACE_OS::last_error() retrieves error code. - */ - virtual int find_value(const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - VALUETYPE& type) = 0; - - /// Removes a named value. - /** - * @param key Configuration section to remove the named value from. - * @param name Name of the configuration value to remove. - * - * @retval 0 for success. - * @retval -1 for error; ACE_OS::last_error() retrieves error code. - */ - virtual int remove_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name) = 0; - - /** - * Expands @a path_in to @a key_out from @a key. If create is true, - * the subsections are created. Returns 0 on success, non zero on - * error The path consists of sections separated by the backslash - * '\' or forward slash '/'. - * Returns 0 on success, -1 if - virtual ~ACE_Section_Key_Win32 (void); - - // Not used - ACE_Section_Key_Win32 (const ACE_Section_Key_Win32& rhs); - ACE_Section_Key_Win32& operator= (const ACE_Section_Key_Win32& rhs); -}; - -/** - * @class ACE_Configuration_Win32Registry - * - * @brief The win32 registry implementation of a configuration database - * - * The win32 implementation basically makes calls through to the - * registry functions. The API is very similar so very little - * work must be done - */ -class ACE_Export ACE_Configuration_Win32Registry : public ACE_Configuration -{ -public: - /** - * Constructor for registry configuration database. hKey is the - * base registry key to attach to. This class takes ownership of - * hKey, it will invoke on it upon destruction. - */ - explicit ACE_Configuration_Win32Registry (HKEY hKey, - u_long security_access = KEY_ALL_ACCESS); - - /// Destructor - virtual ~ACE_Configuration_Win32Registry (void); - - virtual int open_section (const ACE_Configuration_Section_Key& base, - const ACE_TCHAR* sub_section, - bool create, - ACE_Configuration_Section_Key& result); - - virtual int remove_section (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* sub_section, - bool recursive); - - virtual int enumerate_values (const ACE_Configuration_Section_Key& key, - int index, - ACE_TString& name, - VALUETYPE& type); - - virtual int enumerate_sections (const ACE_Configuration_Section_Key& key, - int index, - ACE_TString& name); - - virtual int set_string_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - const ACE_TString& value); - - virtual int set_integer_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - u_int value); - - virtual int set_binary_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - const void* data, - size_t length); - - virtual int get_string_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - ACE_TString& value); - - virtual int get_integer_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - u_int& value); - - virtual int get_binary_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - void*& data, - size_t& length); - - virtual int find_value(const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - VALUETYPE& type); - - /// Removes the the value @a name from @a key. returns non zero on error - virtual int remove_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name); - - /** - * This method traverses through . It is useful when - * you want the HKEY for a specific registry key, especially when - * initializing this implementation. Caller is responsible for - * closeing this key when it is no longer used. If create is 1 - * (default) the keys are create if they don't already exist. - * Returns 0 on error - */ - static HKEY resolve_key (HKEY hKey, - const ACE_TCHAR* path, - bool create = true, - u_long security_access = KEY_ALL_ACCESS); - virtual bool operator== (const ACE_Configuration_Win32Registry &rhs) const; - virtual bool operator!= (const ACE_Configuration_Win32Registry &rhs) const; - -protected: - - /// Gets the HKEY for a configuration section - int load_key (const ACE_Configuration_Section_Key& key, HKEY& hKey); - - // Not used - ACE_Configuration_Win32Registry (void); - ACE_Configuration_Win32Registry (const ACE_Configuration_Win32Registry& rhs); - ACE_Configuration_Win32Registry& operator= (const ACE_Configuration_Win32Registry& rhs); - - const u_long security_access_; -}; -#endif /* ACE_WIN32 && !ACE_LACKS_WIN32_REGISTRY */ - -// ACE_Allocator version - -typedef ACE_Allocator_Adapter > - PERSISTENT_ALLOCATOR; -typedef ACE_Allocator_Adapter > - HEAP_ALLOCATOR; - -/** - * @class ACE_Configuration_ExtId - * - * @brief External ID for the section and value hash - * - * Contains a pointer to the section or value name. - */ -class ACE_Export ACE_Configuration_ExtId -{ -public: - /// Defeault ctor - ACE_Configuration_ExtId (void); - - /// Named constructor - explicit ACE_Configuration_ExtId (const ACE_TCHAR* name); - - /// Copy ctor - ACE_Configuration_ExtId (const ACE_Configuration_ExtId& rhs); - - /// destructor - ~ACE_Configuration_ExtId (void); - - /// Assignment operator - ACE_Configuration_ExtId& operator= (const ACE_Configuration_ExtId& rhs); - - /// Equality comparison operator (must match name_). - bool operator== (const ACE_Configuration_ExtId &rhs) const; - - /// Inequality comparison operator. - bool operator!= (const ACE_Configuration_ExtId &rhs) const; - - /// Frees the name of the value. needed since we don't know the - /// allocator name_ was created in - void free (ACE_Allocator *alloc); - - /// hash function is required in order for this class to be usable by - /// ACE_Hash_Map_Manager. - u_long hash (void) const; - - // = Data members. - - const ACE_TCHAR * name_; - - // Accessors - const ACE_TCHAR *name (void); -}; - -typedef ACE_Hash_Map_With_Allocator - SUBSECTION_MAP; -typedef ACE_Hash_Map_Manager_Ex, - ACE_Equal_To, - ACE_Null_Mutex> - SUBSECTION_HASH; - -/** - * @class ACE_Configuration_Value_IntId - * - * @brief The section hash table internal value class - * - * This class is present as the internal portion of a section's - * value hash table It may store string, integer or binary data. - */ -class ACE_Export ACE_Configuration_Value_IntId -{ -public: - /// Default constructor - ACE_Configuration_Value_IntId (void); - - /// String constructor, takes ownership of string - explicit ACE_Configuration_Value_IntId (ACE_TCHAR* string); - - /// Integer constructor - explicit ACE_Configuration_Value_IntId (u_int integer); - - /// Binary constructor, takes ownership of data - ACE_Configuration_Value_IntId (void* data, size_t length); - - /// Copy ctor - ACE_Configuration_Value_IntId (const ACE_Configuration_Value_IntId& rhs); - - /// Destructor - ~ACE_Configuration_Value_IntId (void); - - /// Assignment operator - ACE_Configuration_Value_IntId& operator= ( - const ACE_Configuration_Value_IntId& rhs); - - void free (ACE_Allocator *alloc); - - // = Data members. - - /** - * Points to the string value or binary data or IS the integer - * Length is only used when type_ == BINARY - */ - ACE_Configuration::VALUETYPE type_; - union { - void * ptr_; - u_int int_; - } data_; - size_t length_; -}; - -typedef ACE_Hash_Map_With_Allocator - VALUE_MAP; -typedef ACE_Hash_Map_Manager_Ex, - ACE_Equal_To, - ACE_Null_Mutex> - VALUE_HASH; - -// Deprecated typedef. Use the VALUE_HASH::ENTRY trait instead. -typedef VALUE_HASH::ENTRY VALUE_ENTRY; - -/** - * @class ACE_Configuration_Section_IntId - * - * @brief The internal ID for a section hash table - * - * Contains a hash table containing value name/values - */ -class ACE_Export ACE_Configuration_Section_IntId -{ -public: - /// Default ctor - ACE_Configuration_Section_IntId (void); - - /// Named ctor - ACE_Configuration_Section_IntId (VALUE_MAP* value_hash_map, - SUBSECTION_MAP* section_hash_map); - - /// Copy ctor - ACE_Configuration_Section_IntId (const ACE_Configuration_Section_IntId& rhs); - - /// Destructor - ~ACE_Configuration_Section_IntId (void); - - /// Assignment operator - ACE_Configuration_Section_IntId& operator= ( - const ACE_Configuration_Section_IntId& rhs); - - /// Frees the hash table and all its values - void free (ACE_Allocator *alloc); - - // = Data Members. - VALUE_MAP* value_hash_map_; - - SUBSECTION_MAP* section_hash_map_; -}; - -typedef ACE_Hash_Map_With_Allocator - SECTION_MAP; -typedef ACE_Hash_Map_Manager_Ex, - ACE_Equal_To, - ACE_Null_Mutex> - SECTION_HASH; - -// Deprecated typedef. Use the SECTION_HASH::ENTRY trait instead. -typedef SECTION_HASH::ENTRY SECTION_ENTRY; - -/** - * @class ACE_Configuration_Section_Key_Heap - * - * @brief Internal section key class for heap based configuration - * database. - * - * Contains a value iterator and full path name of section. - */ -class ACE_Export ACE_Configuration_Section_Key_Heap - : public ACE_Section_Key_Internal -{ -public: - /// Constructor based on the full path of the section - ACE_Configuration_Section_Key_Heap (const ACE_TCHAR* path); - - /// The path itself - ACE_TCHAR* path_; - - /// The value iterator - VALUE_HASH::ITERATOR* value_iter_; - - /// The sub section iterator - SUBSECTION_HASH::ITERATOR* section_iter_; - - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Destructor - will delete the iterators - virtual ~ACE_Configuration_Section_Key_Heap (void); - - // Not used - ACE_Configuration_Section_Key_Heap (const ACE_Configuration_Section_Key_Heap& rhs); - ACE_Configuration_Section_Key_Heap& operator= (const ACE_Configuration_Section_Key_Heap& rhs); -}; - -/** - * @class ACE_Configuration_Heap - * - * @brief The concrete implementation of a allocator based - * configuration database - * - * This class uses ACE's Allocators to manage a memory - * representation of a configuration database. A persistent heap - * may be used to store configurations persistently - * - * @note Before using this class you must call one of the open methods. - * - * @todo - * - Need to investigate what happens if memory mapped file gets mapped to - * a location different than it was created with. - */ -class ACE_Export ACE_Configuration_Heap : public ACE_Configuration -{ -public: - /// Default ctor - ACE_Configuration_Heap (void); - - /// Destructor - virtual ~ACE_Configuration_Heap (void); - - /** - * Opens a configuration that allocates its memory from a memory-mapped file. - * This makes it possible to persist a configuration to permanent storage. - * This is not the same as exporting the configuration to a file; the - * memory-mapped file is not likely to be very readable by humans. - * - * @param file_name Name of the file to map into memory. - * - * @param base_address Address to map the base of @a file_name to. - * - * @param default_map_size Starting size for the internal hash tables that - * contain configuration information. - * - * @retval 0 for success. - * @retval -1 for error, with errno set to indicate the cause. If open() - * is called multiple times, errno will be @c EBUSY. - */ - int open (const ACE_TCHAR* file_name, - void* base_address = ACE_DEFAULT_BASE_ADDR, - size_t default_map_size = ACE_DEFAULT_CONFIG_SECTION_SIZE); - - /** - * Opens a configuration that allocates memory from the heap. - * - * @param default_map_size Starting size for the internal hash tables that - * contain configuration information. - * - * @retval 0 for success. - * @retval -1 for error, with errno set to indicate the cause. If open() - * is called multiple times, errno will be @c EBUSY. - */ - int open (size_t default_map_size = ACE_DEFAULT_CONFIG_SECTION_SIZE); - - virtual int open_section (const ACE_Configuration_Section_Key& base, - const ACE_TCHAR* sub_section, - bool create, ACE_Configuration_Section_Key& result); - - virtual int remove_section (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* sub_section, - bool recursive); - - virtual int enumerate_values (const ACE_Configuration_Section_Key& key, - int index, - ACE_TString& name, - VALUETYPE& type); - - virtual int enumerate_sections (const ACE_Configuration_Section_Key& key, - int index, - ACE_TString& name); - - virtual int set_string_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - const ACE_TString& value); - - virtual int set_integer_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - u_int value); - - virtual int set_binary_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - const void* data, - size_t length); - - virtual int get_string_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - ACE_TString& value); - - virtual int get_integer_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - u_int& value); - - virtual int get_binary_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - void* &data, - size_t &length); - - virtual int find_value(const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name, - VALUETYPE& type); - - /// Removes the the value @a name from @a key. returns non zero on error - virtual int remove_value (const ACE_Configuration_Section_Key& key, - const ACE_TCHAR* name); - -private: - /// @a sub_section may not contain path separators - int open_simple_section (const ACE_Configuration_Section_Key &base, - const ACE_TCHAR *sub_section, - bool create, ACE_Configuration_Section_Key &result); - /// Adds a new section - int add_section (const ACE_Configuration_Section_Key &base, - const ACE_TCHAR *sub_section, - ACE_Configuration_Section_Key &result); - - /// Helper for the method. - int create_index (void); - - /// Helper for create_index() method: places hash table into an - /// allocated space. - int create_index_helper (void *buffer); - - int value_open_helper (size_t hash_table_size, void *buffer); - - int section_open_helper (size_t hash_table_size, void *buffer); - - int load_key (const ACE_Configuration_Section_Key& key, ACE_TString& name); - - int new_section (const ACE_TString& section, - ACE_Configuration_Section_Key& result); - - ACE_Configuration_Heap (const ACE_Configuration_Heap& rhs); - ACE_Configuration_Heap& operator= (const ACE_Configuration_Heap& rhs); - - ACE_Allocator *allocator_; - SECTION_MAP *index_; - size_t default_map_size_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Configuration.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_CONFIGURATION_H */ diff --git a/deps/acelite/ace/Configuration.inl b/deps/acelite/ace/Configuration.inl deleted file mode 100644 index ebd6d6f9e..000000000 --- a/deps/acelite/ace/Configuration.inl +++ /dev/null @@ -1,10 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE const ACE_TCHAR* -ACE_Configuration_ExtId::name (void) -{ - return name_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Configuration_Import_Export.cpp b/deps/acelite/ace/Configuration_Import_Export.cpp deleted file mode 100644 index 3b91d3226..000000000 --- a/deps/acelite/ace/Configuration_Import_Export.cpp +++ /dev/null @@ -1,747 +0,0 @@ -#include "ace/Configuration_Import_Export.h" -#include "ace/OS_Errno.h" -#include "ace/OS_NS_stdio.h" -#include "ace/OS_NS_ctype.h" -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Config_ImpExp_Base::ACE_Config_ImpExp_Base (ACE_Configuration& config) - : config_ (config) -{ -} - -ACE_Config_ImpExp_Base::~ACE_Config_ImpExp_Base (void) -{ -} - -ACE_Registry_ImpExp::ACE_Registry_ImpExp (ACE_Configuration& config) - : ACE_Config_ImpExp_Base (config) -{ -} - -ACE_Registry_ImpExp::~ACE_Registry_ImpExp (void) -{ -} - -// Imports the configuration database from filename. -// No existing data is removed. -int -ACE_Registry_ImpExp::import_config (const ACE_TCHAR* filename) -{ - if (0 == filename) - { - errno = EINVAL; - return -1; - } - FILE* in = ACE_OS::fopen (filename, ACE_TEXT ("r")); - if (!in) - return -1; - - u_int buffer_size = 4096; - u_int read_pos = 0; - ACE_TCHAR *buffer = 0; -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_NORETURN (buffer, static_cast (ACE_Allocator::instance()->malloc(sizeof(ACE_TCHAR) * buffer_size))); -#else - ACE_NEW_NORETURN (buffer, ACE_TCHAR[buffer_size]); -#endif /* ACE_HAS_ALLOC_HOOKS */ - if (!buffer) - { - ACE_Errno_Guard guard (errno); - (void) ACE_OS::fclose (in); - return -1; - } - ACE_Configuration_Section_Key section; - ACE_TCHAR *end = 0; - - while (ACE_OS::fgets (buffer+read_pos, buffer_size - read_pos, in)) - { - // Check if we got all the line. - end = ACE_OS::strrchr (buffer + read_pos, - ACE_TEXT ('\n')); // look for end of line - if (!end) // we havn't reach the end of the line yet - { - // allocate a new buffer - double size the previous one - ACE_TCHAR *temp_buffer; -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_NORETURN (temp_buffer, static_cast (ACE_Allocator::instance()->malloc(sizeof (ACE_TCHAR) * buffer_size * 2))); -#else - ACE_NEW_NORETURN (temp_buffer, ACE_TCHAR[buffer_size * 2]); -#endif /* ACE_HAS_ALLOC_HOOKS */ - if (!temp_buffer) - { - ACE_Errno_Guard guard (errno); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(buffer); -#else - delete [] buffer; -#endif /* ACE_HAS_ALLOC_HOOKS */ - (void) ACE_OS::fclose (in); - return -1; - } - - // copy the beginnning of the line - ACE_OS::memcpy (temp_buffer, buffer, buffer_size); - read_pos = buffer_size - 1; - buffer_size *= 2; -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(buffer); -#else - delete [] buffer; -#endif /* ACE_HAS_ALLOC_HOOKS */ - buffer = temp_buffer; - continue; - } - read_pos = 0; - - // Check for a comment - if (buffer[0] == ACE_TEXT (';') || buffer[0] == ACE_TEXT ('#')) - continue; - - if (buffer[0] == ACE_TEXT ('[')) - { - // We have a new section here, strip out the section name - end = ACE_OS::strrchr (buffer, ACE_TEXT (']')); - if (!end) - { - ACE_OS::fclose (in); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(buffer); -#else - delete [] buffer; -#endif /* ACE_HAS_ALLOC_HOOKS */ - return -3; - } - *end = 0; - - if (config_.expand_path (config_.root_section (), buffer + 1, section, 1)) - { - ACE_OS::fclose (in); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(buffer); -#else - delete [] buffer; -#endif /* ACE_HAS_ALLOC_HOOKS */ - return -3; - } - continue; - } // end if firs char is a [ - - if (buffer[0] == ACE_TEXT ('"')) - { - // we have a value - end = ACE_OS::strchr (buffer+1, '"'); - if (!end) // no closing quote, not a value so just skip it - continue; - - // null terminate the name - *end = 0; - ACE_TCHAR* name = buffer + 1; - end+=2; - // determine the type - if (*end == '\"') - { - // string type - // truncate trailing " - ++end; - ACE_TCHAR* trailing = ACE_OS::strrchr (end, '"'); - if (trailing) - *trailing = 0; - if (config_.set_string_value (section, name, end)) - { - ACE_OS::fclose (in); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(buffer); -#else - delete [] buffer; -#endif /* ACE_HAS_ALLOC_HOOKS */ - return -4; - } - } - else if (ACE_OS::strncmp (end, ACE_TEXT ("dword:"), 6) == 0) - { - // number type - ACE_TCHAR* endptr = 0; - unsigned long value = ACE_OS::strtoul (end + 6, &endptr, 16); - if (config_.set_integer_value (section, name, - static_cast (value))) - { - ACE_OS::fclose (in); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(buffer); -#else - delete [] buffer; -#endif /* ACE_HAS_ALLOC_HOOKS */ - return -4; - } - } - else if (ACE_OS::strncmp (end, ACE_TEXT ("hex:"), 4) == 0) - { - // binary type - size_t string_length = ACE_OS::strlen (end + 4); - // divide by 3 to get the actual buffer length - size_t length = string_length / 3; - size_t remaining = length; - u_char* data = 0; -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (data, - static_cast (ACE_Allocator::instance()->malloc(sizeof(u_char) * length)), - -1); -#else - ACE_NEW_RETURN (data, - u_char[length], - -1); -#endif /* ACE_HAS_ALLOC_HOOKS */ - u_char* out = data; - ACE_TCHAR* inb = end + 4; - ACE_TCHAR* endptr = 0; - while (remaining) - { - u_char charin = (u_char) ACE_OS::strtoul (inb, &endptr, 16); - *out = charin; - ++out; - --remaining; - inb += 3; - } - if (config_.set_binary_value (section, name, data, length)) - { - ACE_OS::fclose (in); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(data); - ACE_Allocator::instance()->free(buffer); -#else - delete [] data; - delete [] buffer; -#endif /* ACE_HAS_ALLOC_HOOKS */ - return -4; - } - else -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(data); -#else - delete [] data; -#endif /* ACE_HAS_ALLOC_HOOKS */ - } - else - { - // invalid type, ignore - continue; - } - }// end if first char is a " - else - { - // if the first character is not a ", [, ;, or # we may be - // processing a file in the old format. - // Try and process the line as such and if it fails, - // return an error - int rc = process_previous_line_format (buffer, section); - if (rc != 0) - { - ACE_OS::fclose (in); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(buffer); -#else - delete [] buffer; -#endif /* ACE_HAS_ALLOC_HOOKS */ - return rc; - } - } // end if maybe old format - } // end while fgets - - if (ferror (in)) - { - ACE_OS::fclose (in); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(buffer); -#else - delete [] buffer; -#endif /* ACE_HAS_ALLOC_HOOKS */ - return -1; - } - - ACE_OS::fclose (in); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(buffer); -#else - delete [] buffer; -#endif /* ACE_HAS_ALLOC_HOOKS */ - return 0; -} - -// This method exports the entire configuration database to . -// Once the file is opened this method calls 'export_section' passing -// the root section. -int -ACE_Registry_ImpExp::export_config (const ACE_TCHAR* filename) -{ - if (0 == filename) - { - errno = EINVAL; - return -1; - } - int result = -1; - - FILE* out = ACE_OS::fopen (filename, ACE_TEXT ("w")); - if (out) - { - result = this->export_section (config_.root_section (), - ACE_TEXT (""), - out); - // The data may have been buffered and will be flush on close, - // so we need to check that the close succeeds. - if (ACE_OS::fclose (out) < 0) - result = -7; - } - return result; -} - - -#if !defined ACE_USES_WCHAR && defined ACE_LACKS_FPUTS -# define ACE_WRITE_STRING write_string -namespace -{ - int write_string (const char *string, FILE *stream) - { - const size_t count = ACE_OS::strlen (string); - return (ACE_OS::fwrite (string, 1, count, stream) < count) ? -1 : 0; - } -} -#else -# define ACE_WRITE_STRING ACE_OS::fputs -#endif - -// Method provided by derived classes in order to write one section -// to the file specified. Called by export_config when exporting -// the entire configuration object. - -int -ACE_Registry_ImpExp::export_section (const ACE_Configuration_Section_Key& section, - const ACE_TString& path, - FILE* out) -{ - // don't export the root - if (path.length ()) - { - // Write out the section header - ACE_TString header = ACE_TEXT ("["); - header += path; - header += ACE_TEXT ("]"); - header += ACE_TEXT ("\n"); - if (ACE_WRITE_STRING (header.fast_rep (), out) < 0) - return -1; - // Write out each value - int index = 0; - ACE_TString name; - ACE_Configuration::VALUETYPE type; - ACE_TString line; - ACE_TCHAR int_value[32]; - ACE_TCHAR bin_value[3]; - void* binary_data; - size_t binary_length; - ACE_TString string_value; - while (!config_.enumerate_values (section, index, name, type)) - { - line = ACE_TEXT ("\"") + name + ACE_TEXT ("\"="); - switch (type) - { - case ACE_Configuration::INTEGER: - { - u_int value; - if (config_.get_integer_value (section, name.fast_rep (), value)) - return -2; - ACE_OS::snprintf (int_value, 32, ACE_TEXT ("%08x"), value); - line += ACE_TEXT ("dword:"); - line += int_value; - break; - } - case ACE_Configuration::STRING: - { - if (config_.get_string_value (section, - name.fast_rep (), - string_value)) - return -2; - line += ACE_TEXT ("\""); - line += string_value + ACE_TEXT ("\""); - break; - } -#ifdef ACE_WIN32 - case ACE_Configuration::INVALID: - break; -#endif - case ACE_Configuration::BINARY: - { - // not supported yet - maybe use BASE64 codeing? - if (config_.get_binary_value (section, - name.fast_rep (), - binary_data, - binary_length)) - return -2; - line += ACE_TEXT ("hex:"); - unsigned char* ptr = (unsigned char*)binary_data; - while (binary_length) - { - if (ptr != binary_data) - { - line += ACE_TEXT (","); - } - ACE_OS::snprintf (bin_value, 3, ACE_TEXT ("%02x"), *ptr); - line += bin_value; - --binary_length; - ++ptr; - } -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(binary_data); -#else - delete [] (char*) binary_data; -#endif /* ACE_HAS_ALLOC_HOOKS */ - break; - } - default: - return -3; - } - line += ACE_TEXT ("\n"); - if (ACE_WRITE_STRING (line.fast_rep (), out) < 0) - return -4; - ++index; - } - } - // Export all sub sections - int index = 0; - ACE_TString name; - ACE_Configuration_Section_Key sub_key; - while (!config_.enumerate_sections (section, index, name)) - { - ACE_TString sub_section (path); - if (path.length ()) - sub_section += ACE_TEXT ("\\"); - sub_section += name; - if (config_.open_section (section, name.fast_rep (), 0, sub_key)) - return -5; - if (export_section (sub_key, sub_section.fast_rep (), out)) - return -6; - ++index; - } - return 0; -} - -// -// This method read the line format origionally used in ACE 5.1 -// -int -ACE_Registry_ImpExp::process_previous_line_format (ACE_TCHAR* buffer, - ACE_Configuration_Section_Key& section) -{ - // Chop any cr/lf at the end of the line. - ACE_TCHAR *endp = ACE_OS::strpbrk (buffer, ACE_TEXT ("\r\n")); - if (endp != 0) - *endp = '\0'; - - // assume this is a value, read in the value name - ACE_TCHAR* end = ACE_OS::strchr (buffer, '='); - if (end) // no =, not a value so just skip it - { - // null terminate the name - *end = 0; - ++end; - // determine the type - if (*end == '\"') - { - // string type - if(config_.set_string_value (section, buffer, end + 1)) - return -4; - } - else if (*end == '#') - { - // number type - u_int value = ACE_OS::atoi (end + 1); - if (config_.set_integer_value (section, buffer, value)) - return -4; - } - } - return 0; -} // end read_previous_line_format - - -ACE_Ini_ImpExp::ACE_Ini_ImpExp (ACE_Configuration& config) - : ACE_Config_ImpExp_Base (config) -{ -} - -ACE_Ini_ImpExp::~ACE_Ini_ImpExp (void) -{ -} - -// Method to read file and populate object. -int -ACE_Ini_ImpExp::import_config (const ACE_TCHAR* filename) -{ - if (0 == filename) - { - errno = EINVAL; - return -1; - } - FILE* in = ACE_OS::fopen (filename, ACE_TEXT ("r")); - if (!in) - return -1; - - // @@ Make this a dynamic size! - ACE_TCHAR buffer[4096]; - ACE_Configuration_Section_Key section; - while (ACE_OS::fgets (buffer, sizeof buffer, in)) - { - ACE_TCHAR *line = this->squish (buffer); - // Check for a comment and blank line - if (line[0] == ACE_TEXT (';') || - line[0] == ACE_TEXT ('#') || - line[0] == '\0') - continue; - - if (line[0] == ACE_TEXT ('[')) - { - // We have a new section here, strip out the section name - ACE_TCHAR* end = ACE_OS::strrchr (line, ACE_TEXT (']')); - if (!end) - { - ACE_OS::fclose (in); - return -3; - } - *end = 0; - - if (config_.expand_path (config_.root_section (), - line + 1, - section, - 1)) - { - ACE_OS::fclose (in); - return -3; - } - - continue; - } - - // We have a line; name ends at equal sign. - ACE_TCHAR *end = ACE_OS::strchr (line, ACE_TEXT ('=')); - if (end == 0) // No '=' - { - ACE_OS::fclose (in); - return -3; - } - *end++ = '\0'; - ACE_TCHAR *name = this->squish (line); -#if 0 - if (ACE_OS::strlen (name) == 0) // No name; just an '=' - { - ACE_OS::fclose (in); - return -3; - } -#endif - // Now find the start of the value - ACE_TCHAR *value = this->squish (end); - size_t value_len = ACE_OS::strlen (value); - if (value_len > 0) - { - // ACE 5.2 (and maybe earlier) exported strings may be enclosed - // in quotes. If string is quote-delimited, strip the quotes. - // Newer exported files don't have quote delimiters. - if (value[0] == ACE_TEXT ('"') && - value[value_len - 1] == ACE_TEXT ('"')) - { - // Strip quotes off both ends. - value[value_len - 1] = '\0'; - ++value; - } - } - - if (config_.set_string_value (section, name, value)) - { - ACE_OS::fclose (in); - return -4; - } - } // end while fgets - - if (ferror (in)) - { - ACE_OS::fclose (in); - return -1; - } - - ACE_OS::fclose (in); - return 0; -} - -// This method exports the entire configuration database to . -// Once the file is opened this method calls 'export_section' passing -// the root section. -int -ACE_Ini_ImpExp::export_config (const ACE_TCHAR* filename) -{ - if (0 == filename) - { - errno = EINVAL; - return -1; - } - int result = -1; - - FILE* out = ACE_OS::fopen (filename, ACE_TEXT ("w")); - if (out) - { - result = this->export_section (config_.root_section (), - ACE_TEXT (""), - out); - // The data may have been buffered and will be flush on close, - // so we need to check that the close succeeds. - if (ACE_OS::fclose (out) < 0) - result = -7; - } - return result; -} - -// Method provided by derived classes in order to write one section to the -// file specified. Called by export_config when exporting the entire -// configuration objet - -int -ACE_Ini_ImpExp::export_section (const ACE_Configuration_Section_Key& section, - const ACE_TString& path, - FILE* out) -{ - // don't export the root - if (path.length ()) - { - // Write out the section header - ACE_TString header = ACE_TEXT ("["); - header += path; - header += ACE_TEXT ("]\n"); - if (ACE_WRITE_STRING (header.fast_rep (), out) < 0) - return -1; - // Write out each value - int index = 0; - ACE_TString name; - ACE_Configuration::VALUETYPE type; - ACE_TString line; - ACE_TCHAR int_value[32]; - ACE_TCHAR bin_value[3]; - void* binary_data; - size_t binary_length; - ACE_TString string_value; - while (!config_.enumerate_values (section, index, name, type)) - { - line = name + ACE_TEXT ("="); - switch (type) - { - case ACE_Configuration::INTEGER: - { - u_int value; - if (config_.get_integer_value (section, name.fast_rep (), value)) - return -2; - ACE_OS::snprintf (int_value, 32, ACE_TEXT ("%08x"), value); - line += int_value; - break; - } - case ACE_Configuration::STRING: - { - if (config_.get_string_value (section, - name.fast_rep (), - string_value)) - return -2; - line += string_value; - break; - } -#ifdef _WIN32 - case ACE_Configuration::INVALID: - break; // JDO added break. Otherwise INVALID is processed - // like BINARY. If that's correct, please remove the - // break and these comments -#endif - case ACE_Configuration::BINARY: - { - // not supported yet - maybe use BASE64 codeing? - if (config_.get_binary_value (section, - name.fast_rep (), - binary_data, - binary_length)) - return -2; - line += ACE_TEXT ("\""); - unsigned char* ptr = (unsigned char*)binary_data; - while (binary_length) - { - if (ptr != binary_data) - { - line += ACE_TEXT (","); - } - ACE_OS::snprintf (bin_value, 3, ACE_TEXT ("%02x"), *ptr); - line += bin_value; - --binary_length; - ++ptr; - } - line += ACE_TEXT ("\""); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(binary_data); -#else - delete [] (char *) binary_data; -#endif /* ACE_HAS_ALLOC_HOOKS */ - break; - } - default: - return -3; - - }// end switch on type - - line += ACE_TEXT ("\n"); - if (ACE_WRITE_STRING (line.fast_rep (), out) < 0) - return -4; - ++index; - }// end while enumerating values - } - // Export all sub sections - int index = 0; - ACE_TString name; - ACE_Configuration_Section_Key sub_key; - while (!config_.enumerate_sections (section, index, name)) - { - ACE_TString sub_section (path); - if (path.length ()) - sub_section += ACE_TEXT ("\\"); - sub_section += name; - if (config_.open_section (section, name.fast_rep (), 0, sub_key)) - return -5; - if (export_section (sub_key, sub_section.fast_rep (), out)) - return -6; - ++index; - } - return 0; - -} - -// Method to squish leading and trailing whitespaces from a string. -// Whitespace is defined as: spaces (' '), tabs ('\t') or end-of-line -// (cr/lf). The terminating nul is moved up to expunge trailing -// whitespace and the returned pointer points at the first -// non-whitespace character in the string, which may be the nul -// terminator if the string is all whitespace. - -ACE_TCHAR * -ACE_Ini_ImpExp::squish (ACE_TCHAR *src) -{ - ACE_TCHAR *cp = 0; - - if (src == 0) - return 0; - - // Start at the end and work backwards over all whitespace. - for (cp = src + ACE_OS::strlen (src) - 1; - cp != src; - --cp) - if (!ACE_OS::ace_isspace (*cp)) - break; - cp[1] = '\0'; // Chop trailing whitespace - - // Now start at the beginning and move over all whitespace. - for (cp = src; ACE_OS::ace_isspace (*cp); ++cp) - continue; - - return cp; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Configuration_Import_Export.h b/deps/acelite/ace/Configuration_Import_Export.h deleted file mode 100644 index f40019ecc..000000000 --- a/deps/acelite/ace/Configuration_Import_Export.h +++ /dev/null @@ -1,211 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Configuration_Import_Export.h - * - * @author Jerry D. Odenwelder Jr. - * Chris Hafey - * - * Classes defined in this file provide the ability to import and export - * ACE Configuration objects to/from disk files. The base class - * ACE_Config_ImpExp_Base provides the common functionality and the derived - * classes implement the import/export functionality for the specific format. - * - * @todo - * - Add locking for thread safety. - * - Provide ability to read file in one format and write in another. - * - See todo's in each class - */ -//============================================================================= - -#ifndef ACE_CONFIGURATION_IMPORT_EXPORT_H -#define ACE_CONFIGURATION_IMPORT_EXPORT_H -#include /**/ "ace/pre.h" - -#include "ace/Configuration.h" -#include "ace/SString.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Config_ImpExp_Base - * - * @brief Base class for file import/export configuration. - * - * This class provides base functionality for configuration objects - * that are persisted in files. It takes an ACE_Configuration - * object that it populates with the data read. - */ -class ACE_Export ACE_Config_ImpExp_Base -{ -public: - /// Constructor taking the ACE_Configuration to import/export to - ACE_Config_ImpExp_Base (ACE_Configuration& config); - - /** - * Destructor - */ - virtual ~ACE_Config_ImpExp_Base (void); - - /** - * Imports the configuration database from @a filename. - * No existing data is removed. - */ - virtual int import_config (const ACE_TCHAR* filename) = 0; - - /** - * This method exports the entire configuration database to @a filename. - * Once the file is opened this method calls 'export_section' passing - * the root section. - */ - virtual int export_config (const ACE_TCHAR* filename) = 0; - -protected: - ACE_Configuration &config_; - -private: - ACE_Config_ImpExp_Base (const ACE_Config_ImpExp_Base&); - ACE_Config_ImpExp_Base& operator= (const ACE_Config_ImpExp_Base&); -}; - -/** - * @class ACE_Registry_ImpExp - * - * @brief Configuration object that imports/exports data to a file formatted - * using the Win32 Registry file export format. This format looks like - * [Section] - * "key"="String Data" - * "key"=dword: numeric data in hexadecimal format - * "key"=hex: binary data - * - * @todo - * - Add dynamic buffer when importing. currently it will not allow - * importing of values greater than a fixed amount (4096 bytes) - */ -class ACE_Export ACE_Registry_ImpExp : public ACE_Config_ImpExp_Base -{ -public: - /// Construction - ACE_Registry_ImpExp (ACE_Configuration&); - - /// Destruction. - virtual ~ACE_Registry_ImpExp (void); - - /** - * Imports the configuration database from @a filename. - * No existing data is removed. - */ - virtual int import_config (const ACE_TCHAR* filename); - - /** - * This method exports the entire configuration database to @a filename. - * Once the file is opened this method calls export_section() passing - * the root section. - */ - virtual int export_config (const ACE_TCHAR* filename); - -private: - int export_section (const ACE_Configuration_Section_Key& section, - const ACE_TString& path, - FILE* out); - - int process_previous_line_format (ACE_TCHAR* buffer, - ACE_Configuration_Section_Key& section); - - ACE_Registry_ImpExp ( const ACE_Registry_ImpExp&); - ACE_Registry_ImpExp& operator= ( const ACE_Registry_ImpExp&); -}; - -/** - * @class ACE_Ini_ImpExp - * - * @brief Imports the configuration database from filename as strings. - * Allows non-typed values. (no #, dword: hex:, etc. prefixes) and - * skips whitespace (tabs and spaces) as in standard .ini and .conf - * files. Values (to right of equal sign) can be double quote - * delimited to embed tabs and spaces in the string. - * Caller must convert string to type. - * - * This method allows for lines in the .ini or .conf file like this: - * - * TimeToLive = 100 - * Delay = FALSE - * Flags = FF34 - * Heading = "ACE - Adaptive Communication Environment" - * - * (note leading whitespace (tabs) in examples below) - * - * SeekIndex = 14 - * TraceLevel = 6 # Can comment lines like this - * Justification = left_justified - * - * The caller can then retrieve the string with the regular - * get_string_value() function and convert the string to the - * desired data type. - * - * @todo - * - Strings with embedded newlines cause the import to fail - * - Strings with embedded quotes " cause the import to fail - * - Importing/exporting for values in the root section does not work - * - Add dynamic buffer when importing. currently it will not allow - * importing of values greater than a fixed amount (4096 bytes) -*/ -class ACE_Export ACE_Ini_ImpExp : public ACE_Config_ImpExp_Base -{ -public: - /** - * Construction - */ - ACE_Ini_ImpExp (ACE_Configuration&); - - /** - * Destructor - */ - virtual ~ACE_Ini_ImpExp (void); - - /** - * Imports the configuration database from @a filename. - * No existing data is removed. - */ - virtual int import_config (const ACE_TCHAR* filename); - - /** - * This method exports the entire configuration database to @a filename. - * Once the file is opened this method calls export_section() passing - * the root section. - */ - virtual int export_config (const ACE_TCHAR* filename); - -private: - /** - * Method provided by derived classes in order to write one section - * to the file specified. Called by export_config() when exporting - * the entire configuration object. - */ - int export_section (const ACE_Configuration_Section_Key& section, - const ACE_TString& path, - FILE* out); - - /** - * Method to squish leading and trailing whitespaces in a string. - * Whitespace is defined as: spaces (' '), tabs ('\\t') or cr/lf. - * Returns a pointer to the first non-whitespace character in the - * buffer provided, or a pointer to the terminating null if the string - * is all whitespace. The terminating null is moved forward to the - * first character past the last non-whitespace. - */ - ACE_TCHAR *squish (ACE_TCHAR *src); - - ACE_Ini_ImpExp (const ACE_Ini_ImpExp&); - ACE_Ini_ImpExp& operator= (const ACE_Ini_ImpExp&); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" -#endif /* ACE_CONFIGURATION_IMPORT_EXPORT_H */ diff --git a/deps/acelite/ace/Connection_Recycling_Strategy.cpp b/deps/acelite/ace/Connection_Recycling_Strategy.cpp deleted file mode 100644 index b5619a674..000000000 --- a/deps/acelite/ace/Connection_Recycling_Strategy.cpp +++ /dev/null @@ -1,13 +0,0 @@ -#include "ace/Connection_Recycling_Strategy.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Connection_Recycling_Strategy::ACE_Connection_Recycling_Strategy (void) -{ -} - -ACE_Connection_Recycling_Strategy::~ACE_Connection_Recycling_Strategy (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Connection_Recycling_Strategy.h b/deps/acelite/ace/Connection_Recycling_Strategy.h deleted file mode 100644 index 763c7e548..000000000 --- a/deps/acelite/ace/Connection_Recycling_Strategy.h +++ /dev/null @@ -1,62 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Connection_Recycling_Strategy.h - * - * @author Doug Schmidt - */ -//============================================================================= -#ifndef ACE_CONNECTION_RECYCLING_STRATEGY_H -#define ACE_CONNECTION_RECYCLING_STRATEGY_H -#include /**/ "ace/pre.h" - -#include "ace/Recyclable.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Connection_Recycling_Strategy - * - * @brief Defines the interface for a connection recycler. - */ -class ACE_Export ACE_Connection_Recycling_Strategy -{ -public: - ACE_Connection_Recycling_Strategy (void); - - /// Virtual Destructor - virtual ~ACE_Connection_Recycling_Strategy (void); - - /// Remove from cache. - virtual int purge (const void *recycling_act) = 0; - - /// Add to cache. - virtual int cache (const void *recycling_act) = 0; - - virtual int recycle_state (const void *recycling_act, - ACE_Recyclable_State new_state) = 0; - - /// Get/Set recycle_state. - virtual ACE_Recyclable_State recycle_state (const void *recycling_act) const = 0; - - /// Mark as closed. - virtual int mark_as_closed (const void *recycling_act) = 0; - - /// Mark as closed.(non-locking version) - virtual int mark_as_closed_i (const void *recycling_act) = 0; - - /// Cleanup hint and reset @a act_holder to zero if @a act_holder != 0. - virtual int cleanup_hint (const void *recycling_act, - void **act_holder = 0) = 0; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#endif /*ACE_CONNECTION_RECYCLING_STRATEGY*/ diff --git a/deps/acelite/ace/Connector.cpp b/deps/acelite/ace/Connector.cpp deleted file mode 100644 index 1303ab9ca..000000000 --- a/deps/acelite/ace/Connector.cpp +++ /dev/null @@ -1,1001 +0,0 @@ -#ifndef ACE_CONNECTOR_CPP -#define ACE_CONNECTOR_CPP - -#include "ace/Connector.h" -#include "ace/ACE.h" -#include "ace/OS_NS_stdio.h" -#include "ace/OS_NS_string.h" -#include "ace/os_include/os_fcntl.h" /* Has ACE_NONBLOCK */ - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc (ACE_NonBlocking_Connect_Handler) -ACE_ALLOC_HOOK_DEFINE_Tco (ACE_Connector) -ACE_ALLOC_HOOK_DEFINE_Tco (ACE_Strategy_Connector) - -template -ACE_NonBlocking_Connect_Handler::ACE_NonBlocking_Connect_Handler (ACE_Connector_Base &connector, - SVC_HANDLER *sh, - long id) - : connector_ (connector), - svc_handler_ (sh), - cleanup_svc_handler_ (0), - timer_id_ (id) -{ - ACE_TRACE ("ACE_NonBlocking_Connect_Handler::ACE_NonBlocking_Connect_Handler"); - - this->reference_counting_policy ().value - (ACE_Event_Handler::Reference_Counting_Policy::ENABLED); - - if (this->svc_handler_ != 0 && - this->svc_handler_->reference_counting_policy ().value () == - ACE_Event_Handler::Reference_Counting_Policy::ENABLED) - { - // If SVC_HANDLER is reference counted then NBCH holds a reference - // in cleanup_svc_handle_ which is both a pointer to SVC_HANDLER - // and a flag that triggers remove_reference in NBCH destructor. - this->cleanup_svc_handler_ = sh; - this->cleanup_svc_handler_->add_reference (); - } -} - -template -ACE_NonBlocking_Connect_Handler::~ACE_NonBlocking_Connect_Handler (void) -{ - if (this->cleanup_svc_handler_) - this->cleanup_svc_handler_->remove_reference (); -} - -template SVC_HANDLER * -ACE_NonBlocking_Connect_Handler::svc_handler (void) -{ - ACE_TRACE ("ACE_NonBlocking_Connect_Handler::svc_handler"); - return this->svc_handler_; -} - -template long -ACE_NonBlocking_Connect_Handler::timer_id (void) -{ - ACE_TRACE ("ACE_NonBlocking_Connect_Handler::timer_id"); - return this->timer_id_; -} - -template void -ACE_NonBlocking_Connect_Handler::timer_id (long id) -{ - ACE_TRACE ("ACE_NonBlocking_Connect_Handler::timer_id"); - this->timer_id_ = id; -} - -template void -ACE_NonBlocking_Connect_Handler::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_NonBlocking_Connect_Handler::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("svc_handler_ = %x"), this->svc_handler_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\ntimer_id_ = %d"), this->timer_id_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -template bool -ACE_NonBlocking_Connect_Handler::close (SVC_HANDLER *&sh) -{ - // Make sure that we haven't already initialized the Svc_Handler. - if (!this->svc_handler_) - return false; - - { - // Exclusive access to the Reactor. - ACE_GUARD_RETURN (ACE_Lock, - ace_mon, - this->reactor ()->lock (), - 0); - - // Double check. - if (!this->svc_handler_) - return false; - - // Remember the Svc_Handler. - sh = this->svc_handler_; - ACE_HANDLE h = sh->get_handle (); - this->svc_handler_ = 0; - - // Remove this handle from the set of non-blocking handles - // in the Connector. - this->connector_.non_blocking_handles ().remove (h); - - // Cancel timer. - if (this->reactor ()->cancel_timer (this->timer_id (), - 0, - 0) == -1) - return false; - - // Remove from Reactor. - if (-1 == this->reactor ()->remove_handler ( - h, - ACE_Event_Handler::ALL_EVENTS_MASK | ACE_Event_Handler::DONT_CALL)) - return false; - } - - return true; -} - - -template int -ACE_NonBlocking_Connect_Handler::handle_timeout -(const ACE_Time_Value &tv, - const void *arg) -{ - // This method is called if a connection times out before completing. - ACE_TRACE ("ACE_NonBlocking_Connect_Handler::handle_timeout"); - - SVC_HANDLER *svc_handler = 0; - int const retval = this->close (svc_handler) ? 0 : -1; - - // Forward to the SVC_HANDLER the that was passed in as a - // magic cookie during ACE_Connector::connect(). This gives the - // SVC_HANDLER an opportunity to take corrective action (e.g., wait - // a few milliseconds and try to reconnect again. - if (svc_handler != 0 && svc_handler->handle_timeout (tv, arg) == -1) - svc_handler->handle_close (svc_handler->get_handle (), - ACE_Event_Handler::TIMER_MASK); - - return retval; -} - - -template int -ACE_NonBlocking_Connect_Handler::handle_input (ACE_HANDLE) -{ - // Called when a failure occurs during asynchronous connection - // establishment. - ACE_TRACE ("ACE_NonBlocking_Connect_Handler::handle_input"); - - SVC_HANDLER *svc_handler = 0; - int const retval = this->close (svc_handler) ? 0 : -1; - - // Close Svc_Handler. - if (svc_handler != 0) - { - svc_handler->close (NORMAL_CLOSE_OPERATION); - } - - return retval; -} - -template int -ACE_NonBlocking_Connect_Handler::handle_close (ACE_HANDLE handle, - ACE_Reactor_Mask m) -{ - // epoll on Linux will, at least sometimes, return EPOLLERR when a connect - // fails, triggering a total removal from the reactor. This is different from - // select()-based systems which select the fd for read on a connect failure. - // So just call handle_input() to rejoin common handling for a failed - // connect. - if (m == ACE_Event_Handler::ALL_EVENTS_MASK) - return this->handle_input (handle); - return -1; -} - -template int -ACE_NonBlocking_Connect_Handler::handle_output (ACE_HANDLE handle) -{ - // Called when a connection is establishment asynchronous. - ACE_TRACE ("ACE_NonBlocking_Connect_Handler::handle_output"); - - // Grab the connector ref before smashing ourselves in close(). - ACE_Connector_Base &connector = this->connector_; - SVC_HANDLER *svc_handler = 0; - int const retval = this->close (svc_handler) ? 0 : -1; - - if (svc_handler != 0) - { - connector.initialize_svc_handler (handle, svc_handler); - } - - return retval; -} - -template int -ACE_NonBlocking_Connect_Handler::handle_exception (ACE_HANDLE h) -{ - // On Win32, the except mask must also be set for asynchronous - // connects. - ACE_TRACE ("ACE_NonBlocking_Connect_Handler::handle_exception"); - return this->handle_output (h); -} - -template int -ACE_NonBlocking_Connect_Handler::resume_handler (void) -{ - return ACE_Event_Handler::ACE_EVENT_HANDLER_NOT_RESUMED; -} - -template void -ACE_Connector::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Connector::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nflags_ = %d"), this->flags_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -template int -ACE_Connector::make_svc_handler (SVC_HANDLER *&sh) -{ - ACE_TRACE ("ACE_Connector::make_svc_handler"); - - if (sh == 0) - ACE_NEW_RETURN (sh, - SVC_HANDLER, - -1); - - // Set the reactor of the newly created to the same - // reactor that this is using. - sh->reactor (this->reactor ()); - return 0; -} - -template int -ACE_Connector::activate_svc_handler (SVC_HANDLER *svc_handler) -{ - ACE_TRACE ("ACE_Connector::activate_svc_handler"); - // No errors initially - int error = 0; - - // See if we should enable non-blocking I/O on the 's - // peer. - if (ACE_BIT_ENABLED (this->flags_, ACE_NONBLOCK) != 0) - { - if (svc_handler->peer ().enable (ACE_NONBLOCK) == -1) - error = 1; - } - // Otherwise, make sure it's disabled by default. - else if (svc_handler->peer ().disable (ACE_NONBLOCK) == -1) - error = 1; - - // We are connected now, so try to open things up. - if (error || svc_handler->open ((void *) this) == -1) - { - // Make sure to close down the to avoid descriptor - // leaks. - // The connection was already made; so this close is a "normal" - // close operation. - svc_handler->close (NORMAL_CLOSE_OPERATION); - return -1; - } - else - return 0; -} - -template PEER_CONNECTOR & -ACE_Connector::connector (void) const -{ - return const_cast (this->connector_); -} - -template int -ACE_Connector::connect_svc_handler -(SVC_HANDLER *&svc_handler, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - ACE_Time_Value *timeout, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr, - int reuse_addr, - int flags, - int perms) -{ - ACE_TRACE ("ACE_Connector::connect_svc_handler"); - - return this->connector_.connect (svc_handler->peer (), - remote_addr, - timeout, - local_addr, - reuse_addr, - flags, - perms); -} - -template int -ACE_Connector::connect_svc_handler -(SVC_HANDLER *&svc_handler, - SVC_HANDLER *&sh_copy, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - ACE_Time_Value *timeout, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr, - int reuse_addr, - int flags, - int perms) -{ - ACE_TRACE ("ACE_Connector::connect_svc_handler"); - - sh_copy = svc_handler; - return this->connector_.connect (svc_handler->peer (), - remote_addr, - timeout, - local_addr, - reuse_addr, - flags, - perms); -} - -template int -ACE_Connector::open (ACE_Reactor *r, int flags) -{ - ACE_TRACE ("ACE_Connector::open"); - this->reactor (r); - this->flags_ = flags; - return 0; -} - -template -ACE_Connector::ACE_Connector (ACE_Reactor *r, - int flags) -{ - ACE_TRACE ("ACE_Connector::ACE_Connector"); - (void) this->open (r, flags); -} - -template int -ACE_Connector::connect -(SVC_HANDLER *&sh, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - const ACE_Synch_Options &synch_options, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr, - int reuse_addr, - int flags, - int perms) -{ - // Initiate connection to peer. - return this->connect_i (sh, - 0, - remote_addr, - synch_options, - local_addr, - reuse_addr, - flags, - perms); -} - -template int -ACE_Connector::connect -(SVC_HANDLER *&sh, - SVC_HANDLER *&sh_copy, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - const ACE_Synch_Options &synch_options, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr, - int reuse_addr, - int flags, - int perms) -{ - // Initiate connection to peer. - return this->connect_i (sh, - &sh_copy, - remote_addr, - synch_options, - local_addr, - reuse_addr, - flags, - perms); -} - -template int -ACE_Connector::connect_i -(SVC_HANDLER *&sh, - SVC_HANDLER **sh_copy, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - const ACE_Synch_Options &synch_options, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr, - int reuse_addr, - int flags, - int perms) -{ - ACE_TRACE ("ACE_Connector::connect_i"); - - // If the user hasn't supplied us with a we'll use the - // factory method to create one. Otherwise, things will remain as - // they are... - if (this->make_svc_handler (sh) == -1) - return -1; - - ACE_Time_Value *timeout = 0; - int const use_reactor = synch_options[ACE_Synch_Options::USE_REACTOR]; - - if (use_reactor) - timeout = const_cast (&ACE_Time_Value::zero); - else - timeout = const_cast (synch_options.time_value ()); - - int result; - if (sh_copy == 0) - result = this->connect_svc_handler (sh, - remote_addr, - timeout, - local_addr, - reuse_addr, - flags, - perms); - else - result = this->connect_svc_handler (sh, - *sh_copy, - remote_addr, - timeout, - local_addr, - reuse_addr, - flags, - perms); - - // Activate immediately if we are connected. - if (result != -1) - return this->activate_svc_handler (sh); - - // Delegate to connection strategy. - if (use_reactor && ACE_OS::last_error () == EWOULDBLOCK) - { - // If the connection hasn't completed and we are using - // non-blocking semantics then register - // ACE_NonBlocking_Connect_Handler with the ACE_Reactor so that - // it will call us back when the connection is complete or we - // timeout, whichever comes first... - if (sh_copy == 0) - result = this->nonblocking_connect (sh, synch_options); - else - result = this->nonblocking_connect (*sh_copy, synch_options); - - // If for some reason the call failed, then - // will be set to the new error. If the call succeeds, however, - // we need to make sure that remains set to - // . - if (result == 0) - errno = EWOULDBLOCK; - } - else - { - // Save/restore errno. - ACE_Errno_Guard error (errno); - // Make sure to close down the service handler to avoid handle - // leaks. - if (sh_copy == 0) - { - if (sh) - sh->close (CLOSE_DURING_NEW_CONNECTION); - } - else if (*sh_copy) - (*sh_copy)->close (CLOSE_DURING_NEW_CONNECTION); - } - - return -1; -} - -template int -ACE_Connector::connect_n -(size_t n, - SVC_HANDLER *sh[], - typename PEER_CONNECTOR::PEER_ADDR remote_addrs[], - ACE_TCHAR *failed_svc_handlers, - const ACE_Synch_Options &synch_options) -{ - int result = 0; - - for (size_t i = 0; i < n; i++) - { - if (this->connect (sh[i], remote_addrs[i], synch_options) == -1 - && !(synch_options[ACE_Synch_Options::USE_REACTOR] - && errno == EWOULDBLOCK)) - { - result = -1; - if (failed_svc_handlers != 0) - // Mark this entry as having failed. - failed_svc_handlers[i] = 1; - } - else if (failed_svc_handlers != 0) - // Mark this entry as having succeeded. - failed_svc_handlers[i] = 0; - } - - return result; -} - -// Cancel a that was started asynchronously. -template int -ACE_Connector::cancel (SVC_HANDLER *sh) -{ - ACE_TRACE ("ACE_Connector::cancel"); - - ACE_Event_Handler *handler = - this->reactor ()->find_handler (sh->get_handle ()); - - if (handler == 0) - return -1; - - // find_handler() increments handler's refcount; ensure we decrement it. - ACE_Event_Handler_var safe_handler (handler); - - NBCH *nbch = - dynamic_cast (handler); - - if (nbch == 0) - return -1; - - SVC_HANDLER *tmp_sh = 0; - - if (nbch->close (tmp_sh) == false) - return -1; - - return 0; -} - -template int -ACE_Connector::nonblocking_connect -(SVC_HANDLER *sh, - const ACE_Synch_Options &synch_options) -{ - ACE_TRACE ("ACE_Connector::nonblocking_connect"); - - // Must have a valid Reactor for non-blocking connects to work. - if (this->reactor () == 0) - return -1; - - // Register the pending SVC_HANDLER so that it can be activated - // later on when the connection completes. - - ACE_HANDLE handle = sh->get_handle (); - long timer_id = -1; - ACE_Time_Value *tv = 0; - NBCH *nbch = 0; - - ACE_NEW_RETURN (nbch, - NBCH (*this, - sh, - -1), - -1); - - ACE_Event_Handler_var safe_nbch (nbch); - - // Exclusive access to the Reactor. - ACE_GUARD_RETURN (ACE_Lock, ace_mon, this->reactor ()->lock (), -1); - - // Register handle with the reactor for connection events. - ACE_Reactor_Mask mask = ACE_Event_Handler::CONNECT_MASK; - if (this->reactor ()->register_handler (handle, - nbch, - mask) == -1) - goto reactor_registration_failure; - - // Add handle to non-blocking handle set. - this->non_blocking_handles ().insert (handle); - - // If we're starting connection under timer control then we need to - // schedule a timeout with the ACE_Reactor. - tv = const_cast (synch_options.time_value ()); - if (tv != 0) - { - timer_id = - this->reactor ()->schedule_timer (nbch, - synch_options.arg (), - *tv); - if (timer_id == -1) - goto timer_registration_failure; - - // Remember timer id. - nbch->timer_id (timer_id); - } - - return 0; - - // Undo previous actions using the ol' "goto label and fallthru" - // trick... - timer_registration_failure: - - // Remove from Reactor. - this->reactor ()->remove_handler (handle, mask); - - // Remove handle from the set of non-blocking handles. - this->non_blocking_handles ().remove (handle); - - /* FALLTHRU */ - - reactor_registration_failure: - // Close the svc_handler - - sh->close (CLOSE_DURING_NEW_CONNECTION); - - return -1; -} - -template -ACE_Connector::~ACE_Connector (void) -{ - ACE_TRACE ("ACE_Connector::~ACE_Connector"); - - this->close (); -} - -template void -ACE_Connector::initialize_svc_handler -(ACE_HANDLE handle, - SVC_HANDLER *svc_handler) -{ - // Try to find out if the reactor uses event associations for the - // handles it waits on. If so we need to reset it. - bool reset_new_handle = - this->reactor ()->uses_event_associations (); - - if (reset_new_handle) - this->connector_.reset_new_handle (handle); - - // Transfer ownership of the ACE_HANDLE to the SVC_HANDLER. - svc_handler->set_handle (handle); - - typename PEER_CONNECTOR::PEER_ADDR raddr; - - // Check to see if we're connected. - if (svc_handler->peer ().get_remote_addr (raddr) != -1) - this->activate_svc_handler (svc_handler); - else // Somethings gone wrong, so close down... - { -#if defined (ACE_WIN32) - // Win32 (at least prior to Windows 2000) has a timing problem. - // If you check to see if the connection has completed too fast, - // it will fail - so wait 35 milliseconds to let it catch up. - ACE_Time_Value tv (0, ACE_NON_BLOCKING_BUG_DELAY); - ACE_OS::sleep (tv); - if (svc_handler->peer ().get_remote_addr (raddr) != -1) - this->activate_svc_handler (svc_handler); - else // do the svc handler close below... -#endif /* ACE_WIN32 */ - svc_handler->close (NORMAL_CLOSE_OPERATION); - } -} - -template void -ACE_Connector::reactor (ACE_Reactor *reactor) -{ - this->reactor_ = reactor; -} - -template ACE_Reactor * -ACE_Connector::reactor (void) const -{ - return this->reactor_; -} - -template ACE_Unbounded_Set & -ACE_Connector::non_blocking_handles (void) -{ - return this->non_blocking_handles_; -} - -template int -ACE_Connector::close (void) -{ - // If there are no non-blocking handle pending, return immediately. - if (this->non_blocking_handles ().size () == 0) - return 0; - - // Exclusive access to the Reactor. - ACE_GUARD_RETURN (ACE_Lock, ace_mon, this->reactor ()->lock (), -1); - - // Go through all the non-blocking handles. It is necessary to - // create a new iterator each time because we remove from the handle - // set when we cancel the Svc_Handler. - ACE_HANDLE *handle = 0; - while (1) - { - ACE_Unbounded_Set_Iterator - iterator (this->non_blocking_handles ()); - if (!iterator.next (handle)) - break; - - ACE_Event_Handler *handler = - this->reactor ()->find_handler (*handle); - if (handler == 0) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%t: Connector::close h %d, no handler\n"), - *handle)); - // Remove handle from the set of non-blocking handles. - this->non_blocking_handles ().remove (*handle); - continue; - } - - // find_handler() incremented handler's refcount; ensure it's decremented - ACE_Event_Handler_var safe_handler (handler); - NBCH *nbch = dynamic_cast (handler); - if (nbch == 0) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%t: Connector::close h %d handler %@ ") - ACE_TEXT ("not a legit handler\n"), - *handle, - handler)); - // Remove handle from the set of non-blocking handles. - this->non_blocking_handles ().remove (*handle); - continue; - } - SVC_HANDLER *svc_handler = nbch->svc_handler (); - - // Cancel the non-blocking connection. - this->cancel (svc_handler); - - // Close the associated Svc_Handler. - svc_handler->close (NORMAL_CLOSE_OPERATION); - } - - return 0; -} - -template int -ACE_Connector::fini (void) -{ - ACE_TRACE ("ACE_Connector::fini"); - - return this->close (); -} - -// Hook called by the explicit dynamic linking facility. - -template int -ACE_Connector::init (int, ACE_TCHAR *[]) -{ - ACE_TRACE ("ACE_Connector::init"); - return -1; -} - -template int -ACE_Connector::suspend (void) -{ - ACE_TRACE ("ACE_Connector::suspend"); - return -1; -} - -template int -ACE_Connector::resume (void) -{ - ACE_TRACE ("ACE_Connector::resume"); - return -1; -} - -template int -ACE_Connector::info (ACE_TCHAR **strp, size_t length) const -{ - ACE_TRACE ("ACE_Connector::info"); - ACE_TCHAR buf[BUFSIZ]; - - ACE_OS::snprintf (buf, BUFSIZ, - ACE_TEXT ("%s\t %s"), - ACE_TEXT ("ACE_Connector"), - ACE_TEXT ("# connector factory\n")); - - if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0) - return -1; - else - ACE_OS::strsncpy (*strp, buf, length); - return static_cast (ACE_OS::strlen (buf)); -} - -template int -ACE_Strategy_Connector::open (ACE_Reactor *r, - int flags) -{ - ACE_TRACE ("ACE_Strategy_Connector::open"); - return this->open (r, 0, 0, 0, flags); -} - -template int -ACE_Strategy_Connector::open -(ACE_Reactor *r, - ACE_Creation_Strategy *cre_s, - ACE_Connect_Strategy *conn_s, - ACE_Concurrency_Strategy *con_s, - int flags) -{ - ACE_TRACE ("ACE_Strategy_Connector::open"); - - this->reactor (r); - - // @@ Not implemented yet. - // this->flags_ = flags; - ACE_UNUSED_ARG (flags); - - // Initialize the creation strategy. - - // First we decide if we need to clean up. - if (this->creation_strategy_ != 0 && - this->delete_creation_strategy_ && - cre_s != 0) - { - delete this->creation_strategy_; - this->creation_strategy_ = 0; - this->delete_creation_strategy_ = false; - } - - if (cre_s != 0) - this->creation_strategy_ = cre_s; - else if (this->creation_strategy_ == 0) - { - ACE_NEW_RETURN (this->creation_strategy_, - CREATION_STRATEGY (0, r), - -1); - this->delete_creation_strategy_ = true; - } - - - // Initialize the accept strategy. - - if (this->connect_strategy_ != 0 && - this->delete_connect_strategy_ && - conn_s != 0) - { - delete this->connect_strategy_; - this->connect_strategy_ = 0; - this->delete_connect_strategy_ = false; - } - - if (conn_s != 0) - this->connect_strategy_ = conn_s; - else if (this->connect_strategy_ == 0) - { - ACE_NEW_RETURN (this->connect_strategy_, - CONNECT_STRATEGY, - -1); - this->delete_connect_strategy_ = true; - } - - // Initialize the concurrency strategy. - - if (this->concurrency_strategy_ != 0 && - this->delete_concurrency_strategy_ && - con_s != 0) - { - delete this->concurrency_strategy_; - this->concurrency_strategy_ = 0; - this->delete_concurrency_strategy_ = false; - } - - if (con_s != 0) - this->concurrency_strategy_ = con_s; - else if (this->concurrency_strategy_ == 0) - { - ACE_NEW_RETURN (this->concurrency_strategy_, - CONCURRENCY_STRATEGY, - -1); - this->delete_concurrency_strategy_ = true; - } - - return 0; -} - -template -ACE_Strategy_Connector::ACE_Strategy_Connector -(ACE_Reactor *reactor, - ACE_Creation_Strategy *cre_s, - ACE_Connect_Strategy *conn_s, - ACE_Concurrency_Strategy *con_s, - int flags) - : base_type (reactor), - creation_strategy_ (0), - delete_creation_strategy_ (false), - connect_strategy_ (0), - delete_connect_strategy_ (false), - concurrency_strategy_ (0), - delete_concurrency_strategy_ (false) -{ - ACE_TRACE ("ACE_Connector::ACE_Strategy_Connector"); - - if (this->open (reactor, cre_s, conn_s, con_s, flags) == -1) - ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE_Strategy_Connector::ACE_Strategy_Connector"))); -} - -template -ACE_Strategy_Connector::~ACE_Strategy_Connector (void) -{ - ACE_TRACE ("ACE_Strategy_Connector::~ACE_Strategy_Connector"); - - // Close down - this->close (); -} - -template int -ACE_Strategy_Connector::close (void) -{ - if (this->delete_creation_strategy_) - delete this->creation_strategy_; - this->delete_creation_strategy_ = false; - this->creation_strategy_ = 0; - - if (this->delete_connect_strategy_) - delete this->connect_strategy_; - this->delete_connect_strategy_ = false; - this->connect_strategy_ = 0; - - if (this->delete_concurrency_strategy_) - delete this->concurrency_strategy_; - this->delete_concurrency_strategy_ = false; - this->concurrency_strategy_ = 0; - - return SUPER::close (); -} - -template int -ACE_Strategy_Connector::make_svc_handler (SVC_HANDLER *&sh) -{ - return this->creation_strategy_->make_svc_handler (sh); -} - -template int -ACE_Strategy_Connector::connect_svc_handler -(SVC_HANDLER *&sh, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - ACE_Time_Value *timeout, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr, - int reuse_addr, - int flags, - int perms) -{ - return this->connect_strategy_->connect_svc_handler (sh, - remote_addr, - timeout, - local_addr, - reuse_addr, - flags, - perms); -} - -template int -ACE_Strategy_Connector::connect_svc_handler -(SVC_HANDLER *&sh, - SVC_HANDLER *&sh_copy, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - ACE_Time_Value *timeout, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr, - int reuse_addr, - int flags, - int perms) -{ - return this->connect_strategy_->connect_svc_handler (sh, - sh_copy, - remote_addr, - timeout, - local_addr, - reuse_addr, - flags, - perms); -} - -template int -ACE_Strategy_Connector::activate_svc_handler (SVC_HANDLER *svc_handler) -{ - return this->concurrency_strategy_->activate_svc_handler (svc_handler, this); -} - -template ACE_Creation_Strategy * -ACE_Strategy_Connector::creation_strategy (void) const -{ - return this->creation_strategy_; -} - -template ACE_Connect_Strategy * -ACE_Strategy_Connector::connect_strategy (void) const -{ - return this->connect_strategy_; -} - -template ACE_Concurrency_Strategy * -ACE_Strategy_Connector::concurrency_strategy (void) const -{ - return this->concurrency_strategy_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_CONNECTOR_C */ diff --git a/deps/acelite/ace/Connector.h b/deps/acelite/ace/Connector.h deleted file mode 100644 index 85ee6894f..000000000 --- a/deps/acelite/ace/Connector.h +++ /dev/null @@ -1,578 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Connector.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_CONNECTOR_H -#define ACE_CONNECTOR_H - -#include /**/ "ace/pre.h" - -#include "ace/Service_Object.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Strategies_T.h" -#include "ace/Synch_Options.h" -#include "ace/Unbounded_Set.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Connector_Base - * - * @brief This base interface allows ACE_NonBlocking_Connect_Handler - * to only care about the SVC_HANDLER template parameter of the - * ACE_Connector. Otherwise, ACE_NonBlocking_Connect_Handler would - * have to be configured with all the template parameters that - * ACE_Connector is configured with. - */ -template -class ACE_Connector_Base -{ -public: - virtual ~ACE_Connector_Base (void) {} - - /// Initialize the Svc_Handler. - virtual void initialize_svc_handler (ACE_HANDLE handle, - SVC_HANDLER *svc_handler) = 0; - - /// Return the handle set representing the non-blocking connects in - /// progress. - virtual ACE_Unbounded_Set &non_blocking_handles (void) = 0; -}; - -/** - * @class ACE_NonBlocking_Connect_Handler - * - * @brief Performs non-blocking connects on behalf of the Connector. - */ -template -class ACE_NonBlocking_Connect_Handler : public ACE_Event_Handler -{ -public: - /// Constructor. - ACE_NonBlocking_Connect_Handler (ACE_Connector_Base &connector, - SVC_HANDLER *, - long timer_id); - - /// Destructor. - ~ACE_NonBlocking_Connect_Handler (void); - - /// Close up and return underlying SVC_HANDLER through @c sh. - /** - * If the return value is true the close was performed successfully, - * implying that this object was removed from the reactor and thereby - * (by means of reference counting decremented to 0) deleted. - * If the return value is false, the close was not successful. - * The @c sh does not have any connection to the return - * value. The argument will return a valid svc_handler object if a - * valid one exists within the object. Returning a valid svc_handler - * pointer also invalidates the svc_handler contained in this - * object. - */ - bool close (SVC_HANDLER *&sh); - - /// Get SVC_HANDLER. - SVC_HANDLER *svc_handler (void); - - /// Get handle. - ACE_HANDLE handle (void); - - /// Set handle. - void handle (ACE_HANDLE); - - /// Get timer id. - long timer_id (void); - - /// Set timer id. - void timer_id (long timer_id); - - /// Called by ACE_Reactor when asynchronous connections fail. - virtual int handle_input (ACE_HANDLE); - - /// Called by ACE_Dev_Poll_Reactor when asynchronous connections fail. - virtual int handle_close (ACE_HANDLE, ACE_Reactor_Mask); - - /// Called by ACE_Reactor when asynchronous connections succeed. - virtual int handle_output (ACE_HANDLE); - - /// Called by ACE_Reactor when asynchronous connections suceeds (on - /// some platforms only). - virtual int handle_exception (ACE_HANDLE fd); - - /// This method is called if a connection times out before - /// completing. - virtual int handle_timeout (const ACE_Time_Value &tv, const void *arg); - - /// Should Reactor resume us if we have been suspended before the upcall? - virtual int resume_handler (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Connector base. - ACE_Connector_Base &connector_; - - /// Associated SVC_HANDLER. - SVC_HANDLER *svc_handler_; - - /// Same as svc_handler_ if svc_handler_ is reference counted. - SVC_HANDLER *cleanup_svc_handler_; - - /// Associated timer id. - long timer_id_; -}; - -/** - * @class ACE_Connector - * - * @brief Generic factory for actively connecting clients and creating - * service handlers (SVC_HANDLERs). - * - * Implements the strategy for actively establishing connections with - * clients. Both blocking and non-blocking connects are supported. - * Moreover, non-blocking connects support timeouts. - * - * An ACE_Connector is parameterized by concrete types that conform to - * the interfaces of SVC_HANDLER and PEER_CONNECTOR described below. - * - * @tparam SVC_HANDLER The name of the concrete type that performs the - * application-specific service. The SVC_HANDLER typically - * inherits from ACE_Svc_Handler. @see Svc_Handler.h. - * - * @tparam PEER_CONNECTOR The name of the class that implements the - * PEER_CONNECTOR endpoint (e.g., ACE_SOCK_Connector) to - * passively establish connections. A PEER_CONNECTOR - * implementation must provide a PEER_STREAM and PEER_ADDR - * trait to identify the type of stream (e.g., - * ACE_SOCK_Stream) and type of address (e.g., ACE_INET_Addr) - * used by the endpoint. - */ -template -class ACE_Connector : public ACE_Connector_Base, public ACE_Service_Object -{ -public: - // Useful STL-style traits. - typedef typename SVC_HANDLER::addr_type addr_type; - typedef PEER_CONNECTOR connector_type; - typedef SVC_HANDLER handler_type; - typedef typename SVC_HANDLER::stream_type stream_type; - typedef typename PEER_CONNECTOR::PEER_ADDR peer_addr_type; - typedef typename PEER_CONNECTOR::PEER_ADDR PEER_ADDR_TYPEDEF; - - /** - * Initialize a connector. @a flags indicates how SVC_HANDLER's - * should be initialized prior to being activated. Right now, the - * only flag that is processed is ACE_NONBLOCK, which enabled - * non-blocking I/O on the SVC_HANDLER when it is opened. - */ - ACE_Connector (ACE_Reactor *r = ACE_Reactor::instance (), - int flags = 0); - - /** - * Initialize a connector. @a flags indicates how SVC_HANDLER's - * should be initialized prior to being activated. Right now, the - * only flag that is processed is ACE_NONBLOCK, which enabled - * non-blocking I/O on the SVC_HANDLER when it is opened. - */ - virtual int open (ACE_Reactor *r = ACE_Reactor::instance (), - int flags = 0); - - /// Shutdown a connector and release resources. - virtual ~ACE_Connector (void); - - // = Connection establishment methods. - - /** - * Initiate connection of @a svc_handler to peer at @a remote_addr - * using @a synch_options. If the caller wants to designate the - * selected @a local_addr they can (and can also insist that the - * @a local_addr be reused by passing a value @a reuse_addr == - * 1). @a flags and @a perms can be used to pass any flags that are - * needed to perform specific operations such as opening a file - * within connect with certain permissions. If the connection fails - * the hook on the @a svc_handler will be called - * automatically to prevent resource leaks. - */ - virtual int connect (SVC_HANDLER *&svc_handler, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr - = reinterpret_cast(peer_addr_type::sap_any), - int reuse_addr = 0, - int flags = O_RDWR, - int perms = 0); - - /** - * This is a variation on the previous method. On cached - * connectors the @a svc_handler_hint variable can be used as a hint - * for future lookups. Since this variable is modified in the - * context of the internal cache its use is thread-safe. But the - * actual svc_handler for the current connection is returned in the - * second parameter @a svc_handler. If the connection fails the - * hook on the @a svc_handler will be called automatically to - * prevent resource leaks. - */ - virtual int connect (SVC_HANDLER *&svc_handler_hint, - SVC_HANDLER *&svc_handler, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - const ACE_Synch_Options &synch_options = ACE_Synch_Options::defaults, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr - = reinterpret_cast(peer_addr_type::sap_any), - int reuse_addr = 0, - int flags = O_RDWR, - int perms = 0); - - /** - * Initiate connection of @a n @a svc_handlers to peers at - * @a remote_addrs using @a synch_options. Returns -1 if failure - * occurs and 0 otherwise. If @a failed_svc_handlers is non-NULL, a - * 1 is placed in the corresponding index of @a failed_svc_handlers - * for each that failed to connect, else a 0 is - * placed in that index. - */ - virtual int connect_n (size_t n, - SVC_HANDLER *svc_handlers[], - typename PEER_CONNECTOR::PEER_ADDR remote_addrs[], - ACE_TCHAR *failed_svc_handlers = 0, - const ACE_Synch_Options &synch_options = - ACE_Synch_Options::defaults); - - /** - * Cancel the @a svc_handler that was started asynchronously. Note that - * this is the only case when the Connector does not actively close - * the @a svc_handler. It is left up to the caller of to - * decide the fate of the @a svc_handler. - */ - virtual int cancel (SVC_HANDLER *svc_handler); - - /// Close down the Connector. All pending non-blocking connects are - /// canceled and the corresponding svc_handler is closed. - virtual int close (void); - - /// Return the underlying PEER_CONNECTOR object. - virtual PEER_CONNECTOR &connector (void) const; - - /// Initialize Svc_Handler. - virtual void initialize_svc_handler (ACE_HANDLE handle, - SVC_HANDLER *svc_handler); - - /// Set Reactor. - virtual void reactor (ACE_Reactor *reactor); - - /// Get Reactor. - virtual ACE_Reactor *reactor (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - // = Helpful typedefs. - typedef ACE_NonBlocking_Connect_Handler NBCH; - - // = The following two methods define the Connector's strategies for - // creating, connecting, and activating SVC_HANDLER's, respectively. - - /** - * Bridge method for creating a SVC_HANDLER. The default is to - * create a new SVC_HANDLER only if @a sh == 0, else @a sh is - * unchanged. However, subclasses can override this policy to - * perform SVC_HANDLER creation in any way that they like (such as - * creating subclass instances of SVC_HANDLER, using a singleton, - * dynamically linking the handler, etc.). Returns -1 if failure, - * else 0. - */ - virtual int make_svc_handler (SVC_HANDLER *&sh); - - /** - * Bridge method for connecting the @a svc_handler to the - * @a remote_addr. The default behavior delegates to the - * . - */ - virtual int connect_svc_handler (SVC_HANDLER *&svc_handler, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - ACE_Time_Value *timeout, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr, - int reuse_addr, - int flags, - int perms); - virtual int connect_svc_handler (SVC_HANDLER *&svc_handler, - SVC_HANDLER *&sh_copy, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - ACE_Time_Value *timeout, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr, - int reuse_addr, - int flags, - int perms); - - /** - * Bridge method for activating a @a svc_handler with the appropriate - * concurrency strategy. The default behavior of this method is to - * activate the SVC_HANDLER by calling its method (which - * allows the SVC_HANDLER to define its own concurrency strategy). - * However, subclasses can override this strategy to do more - * sophisticated concurrency activations (such as creating the - * SVC_HANDLER as an "active object" via multi-threading or - * multi-processing). - */ - virtual int activate_svc_handler (SVC_HANDLER *svc_handler); - - /// Creates and registers ACE_NonBlocking_Connect_Handler. - int nonblocking_connect (SVC_HANDLER *, - const ACE_Synch_Options &); - - /// Implementation of the connect methods. - virtual int connect_i (SVC_HANDLER *&svc_handler, - SVC_HANDLER **sh_copy, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - const ACE_Synch_Options &synch_options, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr, - int reuse_addr, - int flags, - int perms); - - /// Return the handle set representing the non-blocking connects in - /// progress. - ACE_Unbounded_Set &non_blocking_handles (void); - - // = Dynamic linking hooks. - /// Default version does no work and returns -1. Must be overloaded - /// by application developer to do anything meaningful. - virtual int init (int argc, ACE_TCHAR *argv[]); - - /// Calls handle_close() to shutdown the Connector gracefully. - virtual int fini (void); - - /// Default version returns address info in @a buf. - virtual int info (ACE_TCHAR **strp, size_t length) const; - - // = Service management hooks. - /// Default version does no work and returns -1. Must be overloaded - /// by application developer to do anything meaningful. - virtual int suspend (void); - - /// Default version does no work and returns -1. Must be overloaded - /// by application developer to do anything meaningful. - virtual int resume (void); - -private: - /// This is the peer connector factory. - PEER_CONNECTOR connector_; - - /** - * Flags that indicate how SVC_HANDLER's should be initialized - * prior to being activated. Right now, the only flag that is - * processed is ACE_NONBLOCK, which enabled non-blocking I/O on - * the SVC_HANDLER when it is opened. - */ - int flags_; - - /// Pointer to the Reactor. - ACE_Reactor *reactor_; - - /// Handle set representing the non-blocking connects in progress. - ACE_Unbounded_Set non_blocking_handles_; - -}; - -/** - * @class ACE_Strategy_Connector - * - * @brief Abstract factory for creating a service handler - * (SVC_HANDLER), connecting the SVC_HANDLER, and activating the - * SVC_HANDLER. - * - * Implements a flexible and extensible set of strategies for - * actively establishing connections with clients. There are - * three main strategies: (1) creating a SVC_HANDLER, (2) - * actively initiating a new connection from the client, - * and (3) activating the SVC_HANDLER with a - * particular concurrency mechanism after the connection is established. - */ -template -class ACE_Strategy_Connector - : public ACE_Connector -{ -public: - // Useful STL-style traits. - typedef ACE_Creation_Strategy - creation_strategy_type; - typedef ACE_Connect_Strategy - connect_strategy_type; - typedef ACE_Concurrency_Strategy - concurrency_strategy_type; - typedef ACE_Connector - base_type; - - // = Define some useful (old style) traits. - typedef ACE_Creation_Strategy - CREATION_STRATEGY; - typedef ACE_Connect_Strategy - CONNECT_STRATEGY; - typedef ACE_Concurrency_Strategy - CONCURRENCY_STRATEGY; - typedef ACE_Connector - SUPER; - - /** - * Initialize a connector. @a flags indicates how SVC_HANDLER's - * should be initialized prior to being activated. Right now, the - * only flag that is processed is ACE_NONBLOCK, which enabled - * non-blocking I/O on the SVC_HANDLER when it is opened. - */ - ACE_Strategy_Connector (ACE_Reactor *r = ACE_Reactor::instance (), - ACE_Creation_Strategy * = 0, - ACE_Connect_Strategy * = 0, - ACE_Concurrency_Strategy * = 0, - int flags = 0); - - /** - * Initialize a connector. @a flags indicates how SVC_HANDLER's - * should be initialized prior to being activated. Right now, the - * only flag that is processed is ACE_NONBLOCK, which enabled - * non-blocking I/O on the SVC_HANDLER when it is opened. - * Default strategies would be created and used. - */ - virtual int open (ACE_Reactor *r, - int flags); - - /** - * Initialize a connector. @a flags indicates how SVC_HANDLER's - * should be initialized prior to being activated. Right now, the - * only flag that is processed is ACE_NONBLOCK, which enabled - * non-blocking I/O on the SVC_HANDLER when it is opened. - */ - virtual int open (ACE_Reactor *r = ACE_Reactor::instance (), - ACE_Creation_Strategy * = 0, - ACE_Connect_Strategy * = 0, - ACE_Concurrency_Strategy * = 0, - int flags = 0); - - /// Shutdown a connector and release resources. - virtual ~ACE_Strategy_Connector (void); - - /// Close down the Connector - virtual int close (void); - - // = Strategies accessors - virtual ACE_Creation_Strategy *creation_strategy (void) const; - virtual ACE_Connect_Strategy *connect_strategy (void) const; - virtual ACE_Concurrency_Strategy *concurrency_strategy (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - // = The following three methods define the 's strategies - // for creating, connecting, and activating SVC_HANDLER's, - // respectively. - - /** - * Bridge method for creating a SVC_HANDLER. The strategy for - * creating a SVC_HANDLER are configured into the Connector via - * it's . The default is to create a new - * SVC_HANDLER only if @a sh == 0, else @a sh is unchanged. - * However, subclasses can override this policy to perform - * SVC_HANDLER creation in any way that they like (such as - * creating subclass instances of SVC_HANDLER, using a singleton, - * dynamically linking the handler, etc.). Returns -1 if failure, - * else 0. - */ - virtual int make_svc_handler (SVC_HANDLER *&sh); - - /** - * Bridge method for connecting the new connection into the - * SVC_HANDLER. The default behavior delegates to the - * in the . - */ - virtual int connect_svc_handler (SVC_HANDLER *&sh, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - ACE_Time_Value *timeout, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr, - int reuse_addr, - int flags, - int perms); - - /** - * Bridge method for connecting the new connection into the - * SVC_HANDLER. The default behavior delegates to the - * in the . - * @a sh_copy is used to obtain a copy of the @a sh pointer, but that - * can be kept in the stack; the motivation is a bit too long to - * include here, but basically we want to modify @a sh safely, using - * the internal locks in the Connect_Strategy, while saving a TSS - * copy in @a sh_copy, usually located in the stack. - */ - virtual int connect_svc_handler (SVC_HANDLER *&sh, - SVC_HANDLER *&sh_copy, - const typename PEER_CONNECTOR::PEER_ADDR &remote_addr, - ACE_Time_Value *timeout, - const typename PEER_CONNECTOR::PEER_ADDR &local_addr, - int reuse_addr, - int flags, - int perms); - - /** - * Bridge method for activating a SVC_HANDLER with the appropriate - * concurrency strategy. The default behavior of this method is to - * activate the SVC_HANDLER by calling its method (which - * allows the SVC_HANDLER to define its own concurrency strategy). - * However, subclasses can override this strategy to do more - * sophisticated concurrency activations (such as creating the - * SVC_HANDLER as an "active object" via multi-threading or - * multi-processing). - */ - virtual int activate_svc_handler (SVC_HANDLER *svc_handler); - - // = Strategy objects. - - /// Creation strategy for an Connector. - CREATION_STRATEGY *creation_strategy_; - - /// True if Connector created the creation strategy and thus should - /// delete it, else false. - bool delete_creation_strategy_; - - /// Connect strategy for a Connector. - CONNECT_STRATEGY *connect_strategy_; - - /// True if Connector created the connect strategy and thus should - /// delete it, else false. - bool delete_connect_strategy_; - - /// Concurrency strategy for a Connector. - CONCURRENCY_STRATEGY *concurrency_strategy_; - - /// True if Connector created the concurrency strategy and thus should - /// delete it, else false. - bool delete_concurrency_strategy_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Connector.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Connector.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_CONNECTOR_H */ diff --git a/deps/acelite/ace/Containers.cpp b/deps/acelite/ace/Containers.cpp deleted file mode 100644 index 3e86f3afb..000000000 --- a/deps/acelite/ace/Containers.cpp +++ /dev/null @@ -1,7 +0,0 @@ -#include "ace/Containers.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Containers.inl" -#endif /* __ACE_INLINE__ */ - -ACE_ALLOC_HOOK_DEFINE (ACE_DLList_Node) diff --git a/deps/acelite/ace/Containers.h b/deps/acelite/ace/Containers.h deleted file mode 100644 index 4d671ca98..000000000 --- a/deps/acelite/ace/Containers.h +++ /dev/null @@ -1,69 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Containers.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_CONTAINERS_H -#define ACE_CONTAINERS_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template class ACE_Double_Linked_List; -template class ACE_Double_Linked_List_Iterator_Base; -template class ACE_Double_Linked_List_Iterator; -template class ACE_Double_Linked_List_Reverse_Iterator; - -/** - * @class ACE_DLList_Node - * - * @brief Base implementation of element in a DL list. Needed for - * ACE_Double_Linked_List. - */ -class ACE_Export ACE_DLList_Node -{ -public: - friend class ACE_Double_Linked_List; - friend class ACE_Double_Linked_List_Iterator_Base; - friend class ACE_Double_Linked_List_Iterator; - friend class ACE_Double_Linked_List_Reverse_Iterator; - - ACE_DLList_Node (void *i, - ACE_DLList_Node *n = 0, - ACE_DLList_Node *p = 0); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - void *item_; - - ACE_DLList_Node *next_; - ACE_DLList_Node *prev_; - -protected: - ACE_DLList_Node (void); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Containers.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Containers_T.h" - -#include /**/ "ace/post.h" - -#endif /* ACE_CONTAINERS_H */ diff --git a/deps/acelite/ace/Containers.inl b/deps/acelite/ace/Containers.inl deleted file mode 100644 index cd7507d40..000000000 --- a/deps/acelite/ace/Containers.inl +++ /dev/null @@ -1,22 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_DLList_Node::ACE_DLList_Node (void) - : item_ (0), - next_ (0), - prev_ (0) -{ -} - -ACE_INLINE -ACE_DLList_Node::ACE_DLList_Node (void *i, - ACE_DLList_Node *n, - ACE_DLList_Node *p) - : item_ (i), - next_ (n), - prev_ (p) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Containers_T.cpp b/deps/acelite/ace/Containers_T.cpp deleted file mode 100644 index 4fa39569b..000000000 --- a/deps/acelite/ace/Containers_T.cpp +++ /dev/null @@ -1,1898 +0,0 @@ -#ifndef ACE_CONTAINERS_T_CPP -#define ACE_CONTAINERS_T_CPP - -#include "ace/Log_Category.h" -#include "ace/Malloc_Base.h" -#include "ace/OS_Memory.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Containers.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Containers_T.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Bounded_Stack) - -template void -ACE_Bounded_Stack::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Bounded_Stack::dump"); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Bounded_Stack::ACE_Bounded_Stack (size_t size) - : size_ (size), - top_ (0) -{ - ACE_NEW (this->stack_, - T[size]); - ACE_TRACE ("ACE_Bounded_Stack::ACE_Bounded_Stack"); -} - -template -ACE_Bounded_Stack::ACE_Bounded_Stack (const ACE_Bounded_Stack &s) - : size_ (s.size_), - top_ (s.top_) -{ - ACE_NEW (this->stack_, - T[s.size_]); - - ACE_TRACE ("ACE_Bounded_Stack::ACE_Bounded_Stack"); - - for (size_t i = 0; i < this->top_; i++) - this->stack_[i] = s.stack_[i]; -} - -template void -ACE_Bounded_Stack::operator= (const ACE_Bounded_Stack &s) -{ - ACE_TRACE ("ACE_Bounded_Stack::operator="); - - if (&s != this) - { - if (this->size_ < s.size_) - { - delete [] this->stack_; - ACE_NEW (this->stack_, - T[s.size_]); - this->size_ = s.size_; - } - this->top_ = s.top_; - - for (size_t i = 0; i < this->top_; i++) - this->stack_[i] = s.stack_[i]; - } -} - -template -ACE_Bounded_Stack::~ACE_Bounded_Stack (void) -{ - ACE_TRACE ("ACE_Bounded_Stack::~ACE_Bounded_Stack"); - delete [] this->stack_; -} - -// ---------------------------------------- - -ACE_ALLOC_HOOK_DEFINE_Tcs(ACE_Fixed_Stack) - -template void -ACE_Fixed_Stack::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Fixed_Stack::dump"); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Fixed_Stack::ACE_Fixed_Stack (void) - : size_ (ACE_SIZE), - top_ (0) -{ - ACE_TRACE ("ACE_Fixed_Stack::ACE_Fixed_Stack"); -} - -template -ACE_Fixed_Stack::ACE_Fixed_Stack (const ACE_Fixed_Stack &s) - : size_ (s.size_), - top_ (s.top_) -{ - ACE_TRACE ("ACE_Fixed_Stack::ACE_Fixed_Stack"); - for (size_t i = 0; i < this->top_; i++) - this->stack_[i] = s.stack_[i]; -} - -template void -ACE_Fixed_Stack::operator= (const ACE_Fixed_Stack &s) -{ - ACE_TRACE ("ACE_Fixed_Stack::operator="); - - if (&s != this) - { - this->top_ = s.top_; - - for (size_t i = 0; i < this->top_; i++) - this->stack_[i] = s.stack_[i]; - } -} - -template -ACE_Fixed_Stack::~ACE_Fixed_Stack (void) -{ - ACE_TRACE ("ACE_Fixed_Stack::~ACE_Fixed_Stack"); -} - -//---------------------------------------- - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Unbounded_Stack) - -template void -ACE_Unbounded_Stack::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - // ACE_TRACE ("ACE_Unbounded_Stack::dump"); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Unbounded_Stack::ACE_Unbounded_Stack (ACE_Allocator *alloc) - : head_ (0), - cur_size_ (0), - allocator_ (alloc) -{ - // ACE_TRACE ("ACE_Unbounded_Stack::ACE_Unbounded_Stack"); - if (this->allocator_ == 0) - this->allocator_ = ACE_Allocator::instance (); - - ACE_NEW_MALLOC (this->head_, - (ACE_Node *) this->allocator_->malloc (sizeof (ACE_Node)), - ACE_Node); - this->head_->next_ = this->head_; -} - -template void -ACE_Unbounded_Stack::delete_all_nodes (void) -{ - // ACE_TRACE ("ACE_Unbounded_Stack::delete_all_nodes"); - - while (this->is_empty () == 0) - { - ACE_Node *temp = this->head_->next_; - this->head_->next_ = temp->next_; - ACE_DES_FREE_TEMPLATE (temp, this->allocator_->free, - ACE_Node, ); - } - - this->cur_size_ = 0; - - ACE_ASSERT (this->head_ == this->head_->next_ - && this->is_empty ()); -} - -template void -ACE_Unbounded_Stack::copy_all_nodes (const ACE_Unbounded_Stack &s) -{ - // ACE_TRACE ("ACE_Unbounded_Stack::copy_all_nodes"); - - ACE_ASSERT (this->head_ == this->head_->next_); - - ACE_Node *temp = this->head_; - - for (ACE_Node *s_temp = s.head_->next_; - s_temp != s.head_; - s_temp = s_temp->next_) - { - ACE_Node *nptr = temp->next_; - ACE_NEW_MALLOC (temp->next_, - (ACE_Node *) this->allocator_->malloc (sizeof (ACE_Node)), - ACE_Node (s_temp->item_, nptr)); - temp = temp->next_; - } - this->cur_size_ = s.cur_size_; -} - -template -ACE_Unbounded_Stack::ACE_Unbounded_Stack (const ACE_Unbounded_Stack &s) - : head_ (0), - cur_size_ (0), - allocator_ (s.allocator_) -{ - if (this->allocator_ == 0) - this->allocator_ = ACE_Allocator::instance (); - - ACE_NEW_MALLOC (this->head_, - (ACE_Node *) this->allocator_->malloc (sizeof (ACE_Node)), - ACE_Node); - this->head_->next_ = this->head_; - - // ACE_TRACE ("ACE_Unbounded_Stack::ACE_Unbounded_Stack"); - this->copy_all_nodes (s); -} - -template void -ACE_Unbounded_Stack::operator= (const ACE_Unbounded_Stack &s) -{ - // ACE_TRACE ("ACE_Unbounded_Stack::operator="); - - if (this != &s) - { - this->delete_all_nodes (); - this->copy_all_nodes (s); - } -} - -template -ACE_Unbounded_Stack::~ACE_Unbounded_Stack (void) -{ - // ACE_TRACE ("ACE_Unbounded_Stack::~ACE_Unbounded_Stack"); - - this->delete_all_nodes (); - ACE_DES_FREE_TEMPLATE (head_, - this->allocator_->free, - ACE_Node, - ); -} - -template int -ACE_Unbounded_Stack::push (const T &new_item) -{ - // ACE_TRACE ("ACE_Unbounded_Stack::push"); - - ACE_Node *temp = 0; - - ACE_NEW_MALLOC_RETURN (temp, - static_cast *> (this->allocator_->malloc (sizeof (ACE_Node))), - ACE_Node (new_item, this->head_->next_), - -1); - this->head_->next_ = temp; - ++this->cur_size_; - return 0; -} - -template int -ACE_Unbounded_Stack::pop (T &item) -{ - // ACE_TRACE ("ACE_Unbounded_Stack::pop"); - - if (this->is_empty ()) - return -1; - else - { - ACE_Node *temp = this->head_->next_; - item = temp->item_; - this->head_->next_ = temp->next_; - - ACE_DES_FREE_TEMPLATE (temp, - this->allocator_->free, - ACE_Node, - ); - --this->cur_size_; - return 0; - } -} - -template int -ACE_Unbounded_Stack::find (const T &item) const -{ - // ACE_TRACE ("ACE_Unbounded_Stack::find"); - // Set into the dummy node. - this->head_->item_ = item; - - ACE_Node *temp = this->head_->next_; - - // Keep looping until we find the item. - while (!(temp->item_ == item)) - temp = temp->next_; - - // If we found the dummy node then it's not really there, otherwise, - // it is there. - return temp == this->head_ ? -1 : 0; -} - -template int -ACE_Unbounded_Stack::insert (const T &item) -{ - // ACE_TRACE ("ACE_Unbounded_Stack::insert"); - - if (this->find (item) == 0) - return 1; - else - return this->push (item); -} - -template int -ACE_Unbounded_Stack::remove (const T &item) -{ - // ACE_TRACE ("ACE_Unbounded_Stack::remove"); - - // Insert the item to be founded into the dummy node. - this->head_->item_ = item; - - ACE_Node *curr = this->head_; - - while (!(curr->next_->item_ == item)) - curr = curr->next_; - - if (curr->next_ == this->head_) - return -1; // Item was not found. - else - { - ACE_Node *temp = curr->next_; - // Skip over the node that we're deleting. - curr->next_ = temp->next_; - --this->cur_size_; - ACE_DES_FREE_TEMPLATE (temp, - this->allocator_->free, - ACE_Node, - ); - return 0; - } -} - -//-------------------------------------------------- -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Double_Linked_List_Iterator_Base) - -template -ACE_Double_Linked_List_Iterator_Base::ACE_Double_Linked_List_Iterator_Base (const ACE_Double_Linked_List &dll) - : current_ (0), dllist_ (&dll) -{ - // Do nothing -} - -template -ACE_Double_Linked_List_Iterator_Base::ACE_Double_Linked_List_Iterator_Base (const ACE_Double_Linked_List_Iterator_Base &iter) - : current_ (iter.current_), - dllist_ (iter.dllist_) -{ - // Do nothing -} - - -template T * -ACE_Double_Linked_List_Iterator_Base::next (void) const -{ - return this->not_done (); -} - -template int -ACE_Double_Linked_List_Iterator_Base::next (T *&ptr) const -{ - ptr = this->not_done (); - return ptr ? 1 : 0; -} - - -template int -ACE_Double_Linked_List_Iterator_Base::done (void) const -{ - return this->not_done () ? 0 : 1; -} - -template T & -ACE_Double_Linked_List_Iterator_Base::operator* (void) const -{ - return *(this->not_done ()); -} - -// @@ Is this a valid retasking? Make sure to check with Purify and -// whatnot that we're not leaking memory or doing any other screwing things. -template void -ACE_Double_Linked_List_Iterator_Base::reset (ACE_Double_Linked_List &dll) -{ - current_ = 0; - dllist_ = &dll; -} - - template int -ACE_Double_Linked_List_Iterator_Base::go_head (void) -{ - this->current_ = static_cast (dllist_->head_->next_); - return this->current_ ? 1 : 0; -} - -template int -ACE_Double_Linked_List_Iterator_Base::go_tail (void) -{ - this->current_ = static_cast (dllist_->head_->prev_); - return this->current_ ? 1 : 0; -} - -template T * -ACE_Double_Linked_List_Iterator_Base::not_done (void) const -{ - if (this->current_ != this->dllist_->head_) - return this->current_; - else - return 0; -} - -template T * -ACE_Double_Linked_List_Iterator_Base::do_advance (void) -{ - if (this->not_done ()) - { - this->current_ = static_cast (this->current_->next_); - return this->not_done (); - } - else - return 0; -} - -template T * -ACE_Double_Linked_List_Iterator_Base::do_retreat (void) -{ - if (this->not_done ()) - { - this->current_ = static_cast (this->current_->prev_); - return this->not_done (); - } - else - return 0; -} - -template void -ACE_Double_Linked_List_Iterator_Base::dump_i (void) const -{ - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("current_ = %x"), this->current_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -} - -//-------------------------------------------------- -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Double_Linked_List_Iterator) - -template -ACE_Double_Linked_List_Iterator::ACE_Double_Linked_List_Iterator (const ACE_Double_Linked_List &dll) - : ACE_Double_Linked_List_Iterator_Base (dll) -{ - this->current_ = static_cast (dll.head_->next_); - // Advance current_ out of the null area and onto the first item in - // the list -} - -template void -ACE_Double_Linked_List_Iterator::reset (ACE_Double_Linked_List &dll) -{ - this->ACE_Double_Linked_List_Iterator_Base ::reset (dll); - this->current_ = static_cast (dll.head_->next_); - // Advance current_ out of the null area and onto the first item in - // the list -} - -template int -ACE_Double_Linked_List_Iterator::first (void) -{ - return this->go_head (); -} - -template int -ACE_Double_Linked_List_Iterator::advance (void) -{ - return this->do_advance () ? 1 : 0; -} - -template T* -ACE_Double_Linked_List_Iterator::advance_and_remove (bool dont_remove) -{ - T* item = 0; - if (dont_remove) - this->do_advance (); - else - { - item = this->next (); - this->do_advance (); - // It seems dangerous to remove nodes in an iterator, but so it goes... - ACE_Double_Linked_List *dllist = - const_cast *> (this->dllist_); - dllist->remove (item); - } - return item; -} - -template void -ACE_Double_Linked_List_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - this->dump_i (); -#endif /* ACE_HAS_DUMP */ -} - -// Prefix advance. - -template -ACE_Double_Linked_List_Iterator & -ACE_Double_Linked_List_Iterator::operator++ (void) -{ - this->do_advance (); - return *this; -} - - -// Postfix advance. - -template -ACE_Double_Linked_List_Iterator -ACE_Double_Linked_List_Iterator::operator++ (int) -{ - ACE_Double_Linked_List_Iterator retv (*this); - this->do_advance (); - return retv; -} - - -// Prefix reverse. - -template -ACE_Double_Linked_List_Iterator & -ACE_Double_Linked_List_Iterator::operator-- (void) -{ - this->do_retreat (); - return *this; -} - - -// Postfix reverse. - -template -ACE_Double_Linked_List_Iterator -ACE_Double_Linked_List_Iterator::operator-- (int) -{ - ACE_Double_Linked_List_Iterator retv (*this); - this->do_retreat (); - return retv; -} - - -//-------------------------------------------------- -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Double_Linked_List_Reverse_Iterator) - - template -ACE_Double_Linked_List_Reverse_Iterator::ACE_Double_Linked_List_Reverse_Iterator (ACE_Double_Linked_List &dll) - : ACE_Double_Linked_List_Iterator_Base (dll) -{ - this->current_ = static_cast (dll.head_->prev_); - // Advance current_ out of the null area and onto the last item in - // the list -} - -template void -ACE_Double_Linked_List_Reverse_Iterator::reset (ACE_Double_Linked_List &dll) -{ - this->ACE_Double_Linked_List_Iterator_Base ::reset (dll); - this->current_ = static_cast (dll.head_->prev_); - // Advance current_ out of the null area and onto the last item in - // the list -} - -template int -ACE_Double_Linked_List_Reverse_Iterator::first (void) -{ - return this->go_tail (); -} - -template int -ACE_Double_Linked_List_Reverse_Iterator::advance (void) -{ - return this->do_retreat () ? 1 : 0; -} - -template T* -ACE_Double_Linked_List_Reverse_Iterator::advance_and_remove (bool dont_remove) -{ - T* item = 0; - if (dont_remove) - { - this->do_retreat (); - } - else - { - item = this->next (); - this->do_retreat (); - // It seems dangerous to remove nodes in an iterator, but so it goes... - ACE_Double_Linked_List *dllist = - const_cast *> (this->dllist_); - dllist->remove (item); - } - return item; -} - -template void -ACE_Double_Linked_List_Reverse_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - this->dump_i (); -#endif /* ACE_HAS_DUMP */ -} - -// Prefix advance. - -template -ACE_Double_Linked_List_Reverse_Iterator & -ACE_Double_Linked_List_Reverse_Iterator::operator++ (void) -{ - this->do_retreat (); - return *this; -} - - -// Postfix advance. - -template -ACE_Double_Linked_List_Reverse_Iterator -ACE_Double_Linked_List_Reverse_Iterator::operator++ (int) -{ - ACE_Double_Linked_List_Reverse_Iterator retv (*this); - this->do_retreat (); - return retv; -} - - -// Prefix reverse. - -template -ACE_Double_Linked_List_Reverse_Iterator & -ACE_Double_Linked_List_Reverse_Iterator::operator-- (void) -{ - this->do_advance (); - return *this; -} - - -// Postfix reverse. - -template -ACE_Double_Linked_List_Reverse_Iterator -ACE_Double_Linked_List_Reverse_Iterator::operator-- (int) -{ - ACE_Double_Linked_List_Reverse_Iterator retv (*this); - this->do_advance (); - return retv; -} - - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Double_Linked_List) - - template -ACE_Double_Linked_List:: ACE_Double_Linked_List (ACE_Allocator *alloc) - : size_ (0), allocator_ (alloc) -{ - if (this->allocator_ == 0) - this->allocator_ = ACE_Allocator::instance (); - - ACE_NEW_MALLOC (this->head_, - (T *) this->allocator_->malloc (sizeof (T)), - T); - this->init_head (); -} - -template -ACE_Double_Linked_List::ACE_Double_Linked_List (const ACE_Double_Linked_List &cx) - : allocator_ (cx.allocator_) -{ - if (this->allocator_ == 0) - this->allocator_ = ACE_Allocator::instance (); - - ACE_NEW_MALLOC (this->head_, - (T *) this->allocator_->malloc (sizeof (T)), - T); - this->init_head (); - this->copy_nodes (cx); - this->size_ = cx.size_; -} - -template void -ACE_Double_Linked_List::operator= (const ACE_Double_Linked_List &cx) -{ - if (this != &cx) - { - this->delete_nodes (); - this->copy_nodes (cx); - } -} - -template -ACE_Double_Linked_List::~ACE_Double_Linked_List (void) -{ - this->delete_nodes (); - - ACE_DES_FREE (head_, - this->allocator_->free, - T); - - this->head_ = 0; -} - -template int -ACE_Double_Linked_List::is_empty (void) const -{ - return this->size () ? 0 : 1; -} - -template int -ACE_Double_Linked_List::is_full (void) const -{ - return 0; // We have no bound. -} - -template T * -ACE_Double_Linked_List::insert_tail (T *new_item) -{ - // Insert it before , i.e., at tail. - this->insert_element (new_item, 1); - return new_item; -} - -template T * -ACE_Double_Linked_List::insert_head (T *new_item) -{ - this->insert_element (new_item); // Insert it after , i.e., at head. - return new_item; -} - -template T * -ACE_Double_Linked_List::delete_head (void) -{ - if (this->is_empty ()) - return 0; - - T *temp = static_cast (this->head_->next_); - // Detach it from the list. - this->remove_element (temp); - return temp; -} - -template T * -ACE_Double_Linked_List::delete_tail (void) -{ - if (this->is_empty ()) - return 0; - - T *temp = static_cast (this->head_->prev_); - // Detach it from the list. - this->remove_element (temp); - return temp; -} - -template void -ACE_Double_Linked_List::reset (void) -{ - this->delete_nodes (); -} - -template int -ACE_Double_Linked_List::get (T *&item, size_t slot) -{ - ACE_Double_Linked_List_Iterator iter (*this); - - for (size_t i = 0; - i < slot && !iter.done (); - i++) - iter.advance (); - - item = iter.next (); - return item ? 0 : -1; -} - -template size_t -ACE_Double_Linked_List::size (void) const -{ - return this->size_; -} - -template void -ACE_Double_Linked_List::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - // Dump the state of an object. -#endif /* ACE_HAS_DUMP */ -} - -template int -ACE_Double_Linked_List::remove (T *n) -{ - return this->remove_element (n); -} - -template void -ACE_Double_Linked_List::delete_nodes (void) -{ - while (! this->is_empty ()) - { - T * temp = static_cast (this->head_->next_); - this->remove_element (temp); - ACE_DES_FREE (temp, - this->allocator_->free, - T); - } -} - -template void -ACE_Double_Linked_List::copy_nodes (const ACE_Double_Linked_List &c) -{ - for (ACE_Double_Linked_List_Iterator iter (c); - !iter.done (); - iter.advance ()) - { - T* temp = 0; - ACE_NEW_MALLOC (temp, - (T *)this->allocator_->malloc (sizeof (T)), - T (*iter.next ())); - this->insert_tail (temp); - } -} - -template void -ACE_Double_Linked_List::init_head (void) -{ - this->head_->next_ = this->head_; - this->head_->prev_ = this->head_; -} - -template int -ACE_Double_Linked_List::insert_element (T *new_item, - int before, - T *old_item) -{ - if (old_item == 0) - old_item = this->head_; - - if (before) - old_item = static_cast (old_item->prev_); - - new_item->next_ = old_item->next_; - new_item->next_->prev_ = new_item; - new_item->prev_ = old_item; - old_item->next_ = new_item; - ++this->size_; - return 0; // Well, what will cause errors here? -} - -template int -ACE_Double_Linked_List::remove_element (T *item) -{ - // Notice that you have to ensure that item is an element of this - // list. We can't do much checking here. - - if (item == this->head_ || item->next_ == 0 - || item->prev_ == 0 || this->size () == 0) // Can't remove head - return -1; - - item->prev_->next_ = item->next_; - item->next_->prev_ = item->prev_; - item->next_ = item->prev_ = 0; // reset pointers to prevent double removal. - --this->size_; - return 0; -} - -//-------------------------------------------------- -ACE_ALLOC_HOOK_DEFINE_Tcs(ACE_Fixed_Set) - -template size_t -ACE_Fixed_Set::size (void) const -{ - ACE_TRACE ("ACE_Fixed_Set::size"); - return this->cur_size_; -} - -template void -ACE_Fixed_Set::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Fixed_Set::dump"); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Fixed_Set::~ACE_Fixed_Set (void) -{ - ACE_TRACE ("ACE_Fixed_Set::~ACE_Fixed_Set"); - this->cur_size_ = 0; -} - -template -ACE_Fixed_Set::ACE_Fixed_Set (const ACE_Fixed_Set &fs) - : cur_size_ (fs.cur_size_) -{ - ACE_TRACE ("ACE_Fixed_Set::ACE_Fixed_Set"); - - for (size_t i = 0, j = 0; i < fs.max_size_ && j < this->cur_size_; ++i) - if (fs.search_structure_[i].is_free_ == 0) - this->search_structure_[j++] = fs.search_structure_[i]; -} - -template void -ACE_Fixed_Set::operator= (const ACE_Fixed_Set &fs) -{ - ACE_TRACE ("ACE_Fixed_Set::operator="); - - if (this != &fs) - { - this->cur_size_ = fs.cur_size_; - - for (size_t i = 0, j = 0; i < fs.max_size_ && j < this->cur_size_; ++i) - if (fs.search_structure_[i].is_free_ == 0) - this->search_structure_[j++] = fs.search_structure_[i]; - } -} - -template -ACE_Fixed_Set::ACE_Fixed_Set (void) - : cur_size_ (0), - max_size_ (ACE_SIZE) -{ - ACE_TRACE ("ACE_Fixed_Set::ACE_Fixed_Set"); - for (size_t i = 0; i < this->max_size_; i++) - this->search_structure_[i].is_free_ = 1; -} - -template int -ACE_Fixed_Set::find (const T &item) const -{ - ACE_TRACE ("ACE_Fixed_Set::find"); - - for (size_t i = 0, j = 0; i < this->max_size_ && j < this->cur_size_; ++i) - if (this->search_structure_[i].is_free_ == 0) - { - if (this->search_structure_[i].item_ == item) - return 0; - ++j; - } - - return -1; -} - -template int -ACE_Fixed_Set::insert (const T &item) -{ - ACE_TRACE ("ACE_Fixed_Set::insert"); - ssize_t first_free = -1; // Keep track of first free slot. - size_t i; - - for (i = 0; - i < this->max_size_ && first_free == -1; - ++i) - - // First, make sure we don't allow duplicates. - - if (this->search_structure_[i].is_free_ == 0) - { - if (this->search_structure_[i].item_ == item) - return 1; - } - else - first_free = static_cast (i); - - // If we found a free spot let's reuse it. - - if (first_free > -1) - { - this->search_structure_[first_free].item_ = item; - this->search_structure_[first_free].is_free_ = 0; - this->cur_size_++; - return 0; - } - else /* No more room! */ - { - errno = ENOMEM; - return -1; - } -} - -template int -ACE_Fixed_Set::remove (const T &item) -{ - ACE_TRACE ("ACE_Fixed_Set::remove"); - - for (size_t i = 0, j = 0; - i < this->max_size_ && j < this->cur_size_; - ++i) - if (this->search_structure_[i].is_free_ == 0) - { - if (this->search_structure_[i].item_ == item) - { - // Mark this entry as being free. - this->search_structure_[i].is_free_ = 1; - - --this->cur_size_; - return 0; - } - else - ++j; - } - - return -1; -} - -//-------------------------------------------------- -ACE_ALLOC_HOOK_DEFINE_Tcs(ACE_Fixed_Set_Iterator_Base) - -template void -ACE_Fixed_Set_Iterator_Base::dump_i (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Fixed_Set_Iterator_Base::dump_i"); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Fixed_Set_Iterator_Base::ACE_Fixed_Set_Iterator_Base (ACE_Fixed_Set &s) - : s_ (s), - next_ (-1), - iterated_items_ (0) -{ - ACE_TRACE ("ACE_Fixed_Set_Iterator_Base::ACE_Fixed_Set_Iterator_Base"); - this->advance (); -} - -template int -ACE_Fixed_Set_Iterator_Base::advance (void) -{ - ACE_TRACE ("ACE_Fixed_Set_Iterator_Base::advance"); - - if (this->iterated_items_ < this->s_.cur_size_) - { - for (++this->next_; - static_cast (this->next_) < this->s_.max_size_; - ++this->next_) - if (this->s_.search_structure_[this->next_].is_free_ == 0) - { - ++this->iterated_items_; - return 1; - } - } - else - ++this->next_; - - return 0; -} - -template int -ACE_Fixed_Set_Iterator_Base::first (void) -{ - ACE_TRACE ("ACE_Fixed_Set_Iterator_Base::first"); - - next_ = -1; - iterated_items_ = 0; - return this->advance (); -} - -template int -ACE_Fixed_Set_Iterator_Base::done (void) const -{ - ACE_TRACE ("ACE_Fixed_Set_Iterator_Base::done"); - - return ! (this->iterated_items_ < this->s_.cur_size_); -} - -template int -ACE_Fixed_Set_Iterator_Base::next_i (T *&item) -{ - ACE_TRACE ("ACE_Fixed_Set_Iterator_Base::next_i"); - - if (static_cast (this->next_) < this->s_.max_size_) - do - { - if (this->s_.search_structure_[this->next_].is_free_ == 0) - { - item = &this->s_.search_structure_[this->next_].item_; - this->advance (); - return 1; - } - } - while (this->advance () == 1); - - return 0; -} - -//-------------------------------------------------- -ACE_ALLOC_HOOK_DEFINE_Tcs(ACE_Fixed_Set_Iterator) - -template void -ACE_Fixed_Set_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - this->dump_i (); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Fixed_Set_Iterator::ACE_Fixed_Set_Iterator (ACE_Fixed_Set &s) - : ACE_Fixed_Set_Iterator_Base (s) -{ - ACE_TRACE ("ACE_Fixed_Set_Iterator::ACE_Fixed_Set_Iterator"); -} - -template int -ACE_Fixed_Set_Iterator::next (T *&item) -{ - ACE_TRACE ("ACE_Fixed_Set_Iterator::next"); - return this->next_i (item); -} - -template int -ACE_Fixed_Set_Iterator::remove (T *&item) -{ - ACE_TRACE ("ACE_Fixed_Set_Iterator::remove"); - - if (this->s_.search_structure_[this->next_].is_free_ == 0) - { - item = &this->s_.search_structure_[this->next_].item_; - this->s_.remove (*item); - --(this->iterated_items_); - return 1; - } - - return 0; -} - -template T& -ACE_Fixed_Set_Iterator::operator* (void) -{ - T *retv = 0; - - if (this->s_.search_structure_[this->next_].is_free_ == 0) - retv = &this->s_.search_structure_[this->next_].item_; - - ACE_ASSERT (retv != 0); - - return *retv; -} - -//-------------------------------------------------- -ACE_ALLOC_HOOK_DEFINE_Tcs(ACE_Fixed_Set_Const_Iterator) - -template void -ACE_Fixed_Set_Const_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - this->dump_i (); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Fixed_Set_Const_Iterator::ACE_Fixed_Set_Const_Iterator (const ACE_Fixed_Set &s) - : ACE_Fixed_Set_Iterator_Base (s) -{ - ACE_TRACE ("ACE_Fixed_Set_Const_Iterator::ACE_Fixed_Set_Const_Iterator"); -} - -template int -ACE_Fixed_Set_Const_Iterator::next (const T *&item) -{ - ACE_TRACE ("ACE_Fixed_Set_Const_Iterator::next"); - - return this->next_i (item); -} - -template const T& -ACE_Fixed_Set_Const_Iterator::operator* (void) const -{ - const T *retv = 0; - - if (this->s_.search_structure_[this->next_].is_free_ == 0) - retv = &this->s_.search_structure_[this->next_].item_; - - ACE_ASSERT (retv != 0); - - return *retv; -} - -//-------------------------------------------------- -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Bounded_Set) - -template void -ACE_Bounded_Set::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Bounded_Set::dump"); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Bounded_Set::~ACE_Bounded_Set (void) -{ - ACE_TRACE ("ACE_Bounded_Set::~ACE_Bounded_Set"); - delete [] this->search_structure_; -} - -template -ACE_Bounded_Set::ACE_Bounded_Set (void) - : cur_size_ (0), - max_size_ (static_cast (ACE_Bounded_Set::DEFAULT_SIZE)) -{ - ACE_TRACE ("ACE_Bounded_Set::ACE_Bounded_Set"); - - ACE_NEW (this->search_structure_, - typename ACE_Bounded_Set::Search_Structure[this->max_size_]); - - for (size_t i = 0; i < this->max_size_; ++i) - this->search_structure_[i].is_free_ = 1; -} - -template size_t -ACE_Bounded_Set::size (void) const -{ - ACE_TRACE ("ACE_Bounded_Set::size"); - return this->cur_size_; -} - -template -ACE_Bounded_Set::ACE_Bounded_Set (const ACE_Bounded_Set &bs) - : cur_size_ (bs.cur_size_), - max_size_ (bs.max_size_) -{ - ACE_TRACE ("ACE_Bounded_Set::ACE_Bounded_Set"); - - ACE_NEW (this->search_structure_, - typename ACE_Bounded_Set::Search_Structure[this->max_size_]); - - for (size_t i = 0; i < this->cur_size_; i++) - this->search_structure_[i] = bs.search_structure_[i]; -} - -template void -ACE_Bounded_Set::operator= (const ACE_Bounded_Set &bs) -{ - ACE_TRACE ("ACE_Bounded_Set::operator="); - - if (this != &bs) - { - if (this->max_size_ < bs.cur_size_) - { - delete [] this->search_structure_; - ACE_NEW (this->search_structure_, - typename ACE_Bounded_Set::Search_Structure[bs.cur_size_]); - this->max_size_ = bs.cur_size_; - } - - this->cur_size_ = bs.cur_size_; - - for (size_t i = 0; i < this->cur_size_; i++) - this->search_structure_[i] = bs.search_structure_[i]; - } -} - -template -ACE_Bounded_Set::ACE_Bounded_Set (size_t size) - : cur_size_ (0), - max_size_ (size) -{ - ACE_TRACE ("ACE_Bounded_Set::ACE_Bounded_Set"); - ACE_NEW (this->search_structure_, - typename ACE_Bounded_Set::Search_Structure[size]); - - for (size_t i = 0; i < this->max_size_; i++) - this->search_structure_[i].is_free_ = 1; -} - -template int -ACE_Bounded_Set::find (const T &item) const -{ - ACE_TRACE ("ACE_Bounded_Set::find"); - - for (size_t i = 0; i < this->cur_size_; i++) - if (this->search_structure_[i].item_ == item - && this->search_structure_[i].is_free_ == 0) - return 0; - - return -1; -} - -template int -ACE_Bounded_Set::insert (const T &item) -{ - ACE_TRACE ("ACE_Bounded_Set::insert"); - int first_free = -1; // Keep track of first free slot. - size_t i; - - for (i = 0; i < this->cur_size_; i++) - // First, make sure we don't allow duplicates. - - if (this->search_structure_[i].item_ == item - && this->search_structure_[i].is_free_ == 0) - return 1; - else if (this->search_structure_[i].is_free_ && first_free == -1) - first_free = static_cast (i); - - if (first_free > -1) // If we found a free spot let's reuse it. - { - this->search_structure_[first_free].item_ = item; - this->search_structure_[first_free].is_free_ = 0; - return 0; - } - else if (i < this->max_size_) // Insert at the end of the active portion. - { - this->search_structure_[i].item_ = item; - this->search_structure_[i].is_free_ = 0; - this->cur_size_++; - return 0; - } - else /* No more room! */ - { - errno = ENOMEM; - return -1; - } -} - -template int -ACE_Bounded_Set::remove (const T &item) -{ - ACE_TRACE ("ACE_Bounded_Set::remove"); - for (size_t i = 0; i < this->cur_size_; i++) - if (this->search_structure_[i].item_ == item) - { - // Mark this entry as being free. - this->search_structure_[i].is_free_ = 1; - - // If we just unbound the highest entry, then we need to - // figure out where the next highest active entry is. - if (i + 1 == this->cur_size_) - { - while (i > 0 && this->search_structure_[--i].is_free_) - continue; - - if (i == 0 && this->search_structure_[i].is_free_) - this->cur_size_ = 0; - else - this->cur_size_ = i + 1; - } - return 0; - } - - return -1; -} - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Bounded_Set_Iterator) - - template void -ACE_Bounded_Set_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Bounded_Set_Iterator::dump"); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Bounded_Set_Iterator::ACE_Bounded_Set_Iterator (ACE_Bounded_Set &s) - : s_ (s), - next_ (-1) -{ - ACE_TRACE ("ACE_Bounded_Set_Iterator::ACE_Bounded_Set_Iterator"); - this->advance (); -} - -template int -ACE_Bounded_Set_Iterator::advance (void) -{ - ACE_TRACE ("ACE_Bounded_Set_Iterator::advance"); - - for (++this->next_; - static_cast (this->next_) < this->s_.cur_size_ - && this->s_.search_structure_[this->next_].is_free_; - ++this->next_) - continue; - - return static_cast (this->next_) < this->s_.cur_size_; -} - -template int -ACE_Bounded_Set_Iterator::first (void) -{ - ACE_TRACE ("ACE_Bounded_Set_Iterator::first"); - - next_ = -1; - return this->advance (); -} - -template int -ACE_Bounded_Set_Iterator::done (void) const -{ - ACE_TRACE ("ACE_Bounded_Set_Iterator::done"); - - return static_cast (this->next_) >= - this->s_.cur_size_; -} - -template int -ACE_Bounded_Set_Iterator::next (T *&item) -{ - ACE_TRACE ("ACE_Bounded_Set_Iterator::next"); - if (static_cast (this->next_) < this->s_.cur_size_) - { - item = &this->s_.search_structure_[this->next_].item_; - return 1; - } - else - return 0; -} - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_DNode) - - template -ACE_DNode::ACE_DNode (const T &i, ACE_DNode *n, ACE_DNode *p) - : next_ (n), prev_ (p), item_ (i) -{ -} - -template -ACE_DNode::~ACE_DNode (void) -{ -} - -// **************************************************************** - -template void -ACE_Unbounded_Stack_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - // ACE_TRACE ("ACE_Unbounded_Stack_Iterator::dump"); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Unbounded_Stack_Iterator::ACE_Unbounded_Stack_Iterator (ACE_Unbounded_Stack &q) - : current_ (q.head_->next_), - stack_ (q) -{ - // ACE_TRACE ("ACE_Unbounded_Stack_Iterator::ACE_Unbounded_Stack_Iterator"); -} - -template int -ACE_Unbounded_Stack_Iterator::advance (void) -{ - // ACE_TRACE ("ACE_Unbounded_Stack_Iterator::advance"); - this->current_ = this->current_->next_; - return this->current_ != this->stack_.head_; -} - -template int -ACE_Unbounded_Stack_Iterator::first (void) -{ - // ACE_TRACE ("ACE_Unbounded_Stack_Iterator::first"); - this->current_ = this->stack_.head_->next_; - return this->current_ != this->stack_.head_; -} - -template int -ACE_Unbounded_Stack_Iterator::done (void) const -{ - ACE_TRACE ("ACE_Unbounded_Stack_Iterator::done"); - - return this->current_ == this->stack_.head_; -} - -template int -ACE_Unbounded_Stack_Iterator::next (T *&item) -{ - // ACE_TRACE ("ACE_Unbounded_Stack_Iterator::next"); - if (this->current_ == this->stack_.head_) - return 0; - else - { - item = &this->current_->item_; - return 1; - } -} - - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Ordered_MultiSet) - - template -ACE_Ordered_MultiSet::ACE_Ordered_MultiSet (ACE_Allocator *alloc) - : head_ (0) - , tail_ (0) - , cur_size_ (0) - , allocator_ (alloc) -{ - // ACE_TRACE ("ACE_Ordered_MultiSet::ACE_Ordered_MultiSet"); - - if (this->allocator_ == 0) - this->allocator_ = ACE_Allocator::instance (); -} - -template -ACE_Ordered_MultiSet::ACE_Ordered_MultiSet (const ACE_Ordered_MultiSet &us) - : head_ (0) - , tail_ (0) - , cur_size_ (0) - , allocator_ (us.allocator_) -{ - ACE_TRACE ("ACE_Ordered_MultiSet::ACE_Ordered_MultiSet"); - - if (this->allocator_ == 0) - this->allocator_ = ACE_Allocator::instance (); - - this->copy_nodes (us); -} - -template -ACE_Ordered_MultiSet::~ACE_Ordered_MultiSet (void) -{ - // ACE_TRACE ("ACE_Ordered_MultiSet::~ACE_Ordered_MultiSet"); - - this->delete_nodes (); -} - - -template void -ACE_Ordered_MultiSet::operator= (const ACE_Ordered_MultiSet &us) -{ - ACE_TRACE ("ACE_Ordered_MultiSet::operator="); - - if (this != &us) - { - this->delete_nodes (); - this->copy_nodes (us); - } -} - - -template int -ACE_Ordered_MultiSet::insert (const T &item) -{ - // ACE_TRACE ("ACE_Ordered_MultiSet::insert"); - - return this->insert_from (item, this->head_, 0); -} - -template int -ACE_Ordered_MultiSet::insert (const T &new_item, - ITERATOR &iter) -{ - // ACE_TRACE ("ACE_Ordered_MultiSet::insert using iterator"); - - return this->insert_from (new_item, iter.current_, &iter.current_); -} - -template int -ACE_Ordered_MultiSet::remove (const T &item) -{ - // ACE_TRACE ("ACE_Ordered_MultiSet::remove"); - - ACE_DNode *node = 0; - - int result = locate (item, 0, node); - - // if we found the node, remove from list and free it - if (node && (result == 0)) - { - if (node->prev_) - node->prev_->next_ = node->next_; - else - head_ = node->next_; - - if (node->next_) - node->next_->prev_ = node->prev_; - else - tail_ = node->prev_; - - --this->cur_size_; - - ACE_DES_FREE_TEMPLATE (node, - this->allocator_->free, - ACE_DNode, - ); - return 0; - } - - return -1; -} - -template int -ACE_Ordered_MultiSet::find (const T &item, - ITERATOR &iter) const -{ - // search an occurrence of item, using iterator's current position as a hint - ACE_DNode *node = iter.current_; - int const result = locate (item, node, node); - - // if we found the node, update the iterator and indicate success - if (node && (result == 0)) - { - iter.current_ = node; - return 0; - } - - return -1; -} - - - -template void -ACE_Ordered_MultiSet::reset (void) -{ - ACE_TRACE ("reset"); - - this->delete_nodes (); -} - -template void -ACE_Ordered_MultiSet::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - // ACE_TRACE ("ACE_Ordered_MultiSet::dump"); - // - // ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nhead_ = %u"), this->head_)); - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nhead_->next_ = %u"), this->head_->next_)); - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\ncur_size_ = %d\n"), this->cur_size_)); - // - // T *item = 0; - // size_t count = 1; - // - // for (ACE_Ordered_MultiSet_Iterator iter (*(ACE_Ordered_MultiSet *) this); - // iter.next (item) != 0; - // iter.advance ()) - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("count = %d\n"), count++)); - // - // ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -template int -ACE_Ordered_MultiSet::insert_from (const T &item, ACE_DNode *position, - ACE_DNode **new_position) -{ - // ACE_TRACE ("ACE_Ordered_MultiSet::insert_from"); - - // create a new node - ACE_DNode *temp = 0; - ACE_NEW_MALLOC_RETURN (temp, - static_cast*> (this->allocator_->malloc (sizeof (ACE_DNode))), - ACE_DNode (item), - -1); - // obtain approximate location of the node - int result = locate (item, position, position); - - // if there are nodes in the multiset - if (position) - { - switch (result) - { - // insert after the approximate position - case -1: - - // if there is a following node - if (position->next_) - { - // link up with the following node - position->next_->prev_ = temp; - temp->next_ = position->next_; - } - else - // appending to the end of the set - tail_ = temp; - - // link up with the preceeding node - temp->prev_ = position; - position->next_ = temp; - - break; - - // insert before the position - case 0: - case 1: - - // if there is a preceeding node - if (position->prev_) - { - // link up with the preceeding node - position->prev_->next_ = temp; - temp->prev_ = position->prev_; - } - else - // prepending to the start of the set - head_ = temp; - - // link up with the preceeding node - temp->next_ = position; - position->prev_ = temp; - - break; - - default: - return -1; - } - } - else - { - // point the head and tail to the new node. - this->head_ = temp; - this->tail_ = temp; - } - - ++this->cur_size_; - if (new_position) - *new_position = temp; - - return 0; -} - -template int -ACE_Ordered_MultiSet::locate (const T &item, ACE_DNode *start_position, - ACE_DNode *&new_position) const -{ - if (! start_position) - start_position = this->head_; - - // If starting before the item, move forward until at or just before - // item. - while (start_position && start_position->item_ < item && - start_position->next_) - start_position = start_position->next_; - - // If starting after the item, move back until at or just after item - while (start_position && item < start_position->item_ && - start_position->prev_) - start_position = start_position->prev_; - - // Save the (approximate) location in the passed pointer. - new_position = start_position; - - // Show the location is after (1), before (-1) , or at (0) the item - if (!new_position) - return 1; - else if (item < new_position->item_) - return 1; - else if (new_position->item_ < item) - return -1; - else - return 0; -} - -// Looks for first occurrence of in the ordered set, using the -// passed starting position as a hint: if there is such an instance, -// it updates the new_position pointer to point to one such node and -// returns 0; if there is no such node, then if there is a node before -// where the item would have been, it updates the new_position pointer -// to point to this node and returns -1; if there is no such node, -// then if there is a node after where the item would have been, it -// updates the new_position pointer to point to this node (or 0 if -// there is no such node) and returns 1; - -template void -ACE_Ordered_MultiSet::copy_nodes (const ACE_Ordered_MultiSet &us) -{ - ACE_DNode *insertion_point = this->head_; - - for (ACE_DNode *curr = us.head_; - curr != 0; - curr = curr->next_) - this->insert_from (curr->item_, insertion_point, &insertion_point); -} - -template void -ACE_Ordered_MultiSet::delete_nodes (void) -{ - // iterate through list, deleting nodes - for (ACE_DNode *curr = this->head_; - curr != 0; - ) - { - ACE_DNode *temp = curr; - curr = curr->next_; - ACE_DES_FREE_TEMPLATE (temp, - this->allocator_->free, - ACE_DNode, - ); - } - - this->head_ = 0; - this->tail_ = 0; - this->cur_size_ = 0; -} - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Ordered_MultiSet_Iterator) - -template -ACE_Ordered_MultiSet_Iterator::ACE_Ordered_MultiSet_Iterator (ACE_Ordered_MultiSet &s) - : current_ (s.head_), - set_ (s) -{ - // ACE_TRACE ("ACE_Ordered_MultiSet_Iterator::ACE_Ordered_MultiSet_Iterator"); -} - -template int -ACE_Ordered_MultiSet_Iterator::next (T *&item) const -{ - // ACE_TRACE ("ACE_Ordered_MultiSet_Iterator::next"); - if (this->current_) - { - item = &this->current_->item_; - return 1; - } - - return 0; -} - -template T& -ACE_Ordered_MultiSet_Iterator::operator* (void) -{ - //ACE_TRACE ("ACE_Ordered_MultiSet_Iterator::operator*"); - T *retv = 0; - - int const result = this->next (retv); - ACE_ASSERT (result != 0); - ACE_UNUSED_ARG (result); - - return *retv; -} - -template T * -ACE_DLList::insert_tail (T *new_item) -{ - ACE_DLList_Node *temp1 = 0; - ACE_NEW_MALLOC_RETURN (temp1, - static_cast (this->allocator_->malloc (sizeof (ACE_DLList_Node))), - ACE_DLList_Node (new_item), - 0); - ACE_DLList_Node *temp2 = ACE_DLList_Base::insert_tail (temp1); - return (T *) (temp2 ? temp2->item_ : 0); -} - -template T * -ACE_DLList::insert_head (T *new_item) -{ - ACE_DLList_Node *temp1 = 0; - ACE_NEW_MALLOC_RETURN (temp1, - (ACE_DLList_Node *) this->allocator_->malloc (sizeof (ACE_DLList_Node)), - ACE_DLList_Node (new_item), 0); - ACE_DLList_Node *temp2 = ACE_DLList_Base::insert_head (temp1); - return (T *) (temp2 ? temp2->item_ : 0); -} - -template T * -ACE_DLList::delete_head (void) -{ - ACE_DLList_Node *temp1 = ACE_DLList_Base::delete_head (); - T *temp2 = (T *) (temp1 ? temp1->item_ : 0); - ACE_DES_FREE (temp1, - this->allocator_->free, - ACE_DLList_Node); - - return temp2; -} - -template T * -ACE_DLList::delete_tail (void) -{ - ACE_DLList_Node *temp1 = ACE_DLList_Base::delete_tail (); - T *temp2 = (T *) (temp1 ? temp1->item_ : 0); - ACE_DES_FREE (temp1, - this->allocator_->free, - ACE_DLList_Node); - return temp2; -} - -// **************************************************************** - -// Compare this array with for equality. - -template bool -ACE_Array::operator== (const ACE_Array &s) const -{ - if (this == &s) - return true; - else if (this->size () != s.size ()) - return false; - - const size_t len = s.size (); - for (size_t slot = 0; slot < len; ++slot) - if ((*this)[slot] != s[slot]) - return false; - - return true; -} - -// **************************************************************** - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_CONTAINERS_T_CPP */ diff --git a/deps/acelite/ace/Containers_T.h b/deps/acelite/ace/Containers_T.h deleted file mode 100644 index 90a967b6f..000000000 --- a/deps/acelite/ace/Containers_T.h +++ /dev/null @@ -1,2034 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Containers_T.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_CONTAINERS_T_H -#define ACE_CONTAINERS_T_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -// Need by ACE_DLList_Node. -#include "ace/Containers.h" - -// Shared with "ace/Unbounded_Set.h" -#include "ace/Node.h" - -// Backwards compatibility, please include "ace/Array_Base.h" directly. -#include "ace/Array_Base.h" - -// Backwards compatibility, please include "ace/Unbounded_Set.h" directly. -#include "ace/Unbounded_Set.h" - -// Backwards compatibility, please include "ace/Unbounded_Queue.h" directly. -#include "ace/Unbounded_Queue.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Allocator; - - -/** - * @class ACE_Bounded_Stack - * - * @brief Implement a generic LIFO abstract data type. - * - * This implementation of a Stack uses a bounded array - * that is allocated dynamically. The Stack interface - * provides the standard constant time push, pop, and top - * operations. - * - * Requirements and Performance Characteristics - * - Internal Structure - * Dynamic array - * - Duplicates allowed? - * Yes - * - Random access allowed? - * No - * - Search speed - * N/A - * - Insert/replace speed - * N/A - * - Iterator still valid after change to container? - * N/A - * - Frees memory for removed elements? - * No - * - Items inserted by - * Value - * - Requirements for contained type - * -# Default constructor - * -# Copy constructor - * -# operator= - */ -template -class ACE_Bounded_Stack -{ -public: - // = Initialization, assignment, and termination methods. - - /// Initialize a new empty stack with the provided size.. - /** - * Initialize and allocate space for a new Bounded_Stack with the provided - * size. - */ - ACE_Bounded_Stack (size_t size); - - /// Initialize the stack to be a copy of the stack provided. - /** - * Initialize the stack to be an exact copy of the Bounded_Stack provided - * as a parameter. - */ - ACE_Bounded_Stack (const ACE_Bounded_Stack &s); - - /// Assignment operator - /** - * Perform a deep copy operation using the Bounded_Stack parameter. If the - * capacity of the lhs isn't sufficient for the rhs, then the underlying data - * structure will be reallocated to accomadate the larger number of elements. - */ - void operator= (const ACE_Bounded_Stack &s); - - /// Perform actions needed when stack goes out of scope. - /** - * Deallocate the memory used by the Bounded_Stack. - */ - ~ACE_Bounded_Stack (void); - - // = Classic Stack operations. - - ///Add an element to the top of the stack. - /** - * Place a new item on top of the stack. Returns -1 if the stack - * is already full, 0 if the stack is not already full, and -1 if - * failure occurs. - */ - int push (const T &new_item); - - ///Remove an item from the top of stack. - /** - * Remove and return the top stack item. Returns -1 if the stack is - * already empty, 0 if the stack is not already empty, and -1 if - * failure occurs. - */ - int pop (T &item); - - ///Examine the contents of the top of stack. - /** - * Return top stack item without removing it. Returns -1 if the - * stack is already empty, 0 if the stack is not already empty, and - * -1 if failure occurs. - */ - int top (T &item) const; - - // = Check boundary conditions. - - /// Returns 1 if the container is empty, otherwise returns 0. - /** - * Performs constant time check to determine if the stack is empty. - */ - int is_empty (void) const; - - /// Returns 1 if the container is full, otherwise returns 0. - /** - * Performs constant time check to determine if the stack is at capacity. - */ - int is_full (void) const; - - /// The number of items in the stack. - /** - * Return the number of items currently in the stack. - */ - size_t size (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Size of the dynamically allocated data. - size_t size_; - - /// Keeps track of the current top of stack. - size_t top_; - - /// Holds the stack's contents. - T *stack_; -}; - -//---------------------------------------- - - -/** - * @class ACE_Fixed_Stack - * - * @brief Implement a generic LIFO abstract data type. - * - * This implementation of a Stack uses a fixed array - * with the size fixed at instantiation time. - * - * Requirements and Performance Characteristics - * - Internal Structure - * Fixed array - * - Duplicates allowed? - * Yes - * - Random access allowed? - * No - * - Search speed - * N/A - * - Insert/replace speed - * N/A - * - Iterator still valid after change to container? - * N/A - * - Frees memory for removed elements? - * No - * - Items inserted by - * Value - * - Requirements for contained type - * -# Default constructor - * -# Copy constructor - * -# operator= - */ -template -class ACE_Fixed_Stack -{ -public: - // = Initialization, assignment, and termination methods. - /// Initialize a new stack so that it is empty. - /** - * Initialize an empty stack. - */ - ACE_Fixed_Stack (void); - - /// The copy constructor (performs initialization). - /** - * Initialize the stack and copy the provided stack into the current stack. - */ - ACE_Fixed_Stack (const ACE_Fixed_Stack &s); - - /// Assignment operator (performs assignment). - /** - * Perform a deep copy of the provided stack. - */ - void operator= (const ACE_Fixed_Stack &s); - - /// Perform actions needed when stack goes out of scope. - /** - * Destroy the stack. - */ - ~ACE_Fixed_Stack (void); - - // = Classic Stack operations. - - ///Constant time placement of element on top of stack. - /** - * Place a new item on top of the stack. Returns -1 if the stack - * is already full, 0 if the stack is not already full, and -1 if - * failure occurs. - */ - int push (const T &new_item); - - ///Constant time removal of top of stack. - /** - * Remove and return the top stack item. Returns -1 if the stack is - * already empty, 0 if the stack is not already empty, and -1 if - * failure occurs. - */ - int pop (T &item); - - ///Constant time examination of top of stack. - /** - * Return top stack item without removing it. Returns -1 if the - * stack is already empty, 0 if the stack is not already empty, and - * -1 if failure occurs. - */ - int top (T &item) const; - - // = Check boundary conditions. - - /// Returns 1 if the container is empty, otherwise returns 0. - /** - * Performs constant time check to see if stack is empty. - */ - int is_empty (void) const; - - /// Returns 1 if the container is full, otherwise returns 0. - /** - * Performs constant time check to see if stack is full. - */ - int is_full (void) const; - - /// The number of items in the stack. - /** - * Constant time access to the current size of the stack. - */ - size_t size (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Size of the allocated data. - size_t size_; - - /// Keeps track of the current top of stack. - size_t top_; - - /// Holds the stack's contents. - T stack_[ACE_SIZE]; -}; - -//---------------------------------------- - -template class ACE_Ordered_MultiSet; -template class ACE_Ordered_MultiSet_Iterator; - -/** - * @class ACE_DNode - * - * @brief Implementation element in a bilinked list. - */ -template -class ACE_DNode -{ - friend class ACE_Ordered_MultiSet; - friend class ACE_Ordered_MultiSet_Iterator; - -public: - /// This isn't necessary, but it keeps some compilers happy. - ~ACE_DNode (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - ACE_DNode (const T &i, ACE_DNode *n = 0, ACE_DNode *p = 0); - - /// Pointer to next element in the list of {ACE_DNode}s. - ACE_DNode *next_; - - /// Pointer to previous element in the list of {ACE_DNode}s. - ACE_DNode *prev_; - - /// Current value of the item in this node. - T item_; -}; - - - -/** - * @class ACE_Unbounded_Stack - * - * @brief Implement a generic LIFO abstract data type. - * - * This implementation of an unbounded Stack uses a linked list. - * If you use the {insert} or {remove} methods you should keep - * in mind that duplicate entries aren't allowed. In general, - * therefore, you should avoid the use of these methods since - * they aren't really part of the ADT stack. The stack is implemented - * as a doubly linked list. - * - * Requirements and Performance Characteristics - * - Internal Structure - * Double linked list - * - Duplicates allowed? - * No - * - Random access allowed? - * No - * - Search speed - * Linear - * - Insert/replace speed - * Linear - * - Iterator still valid after change to container? - * Yes - * - Frees memory for removed elements? - * Yes - * - Items inserted by - * Value - * - Requirements for contained type - * -# Default constructor - * -# Copy constructor - * -# operator= - */ -template -class ACE_Unbounded_Stack -{ -public: - friend class ACE_Unbounded_Stack_Iterator; - - // Trait definition. - typedef ACE_Unbounded_Stack_Iterator ITERATOR; - - // = Initialization, assignment, and termination methods. - /// Initialize a new stack so that it is empty. Use user defined - /// allocation strategy if specified. - /** - * Initialize an empty stack using the user specified allocation strategy - * if provided. - */ - ACE_Unbounded_Stack (ACE_Allocator *the_allocator = 0); - - /// The copy constructor (performs initialization). - /** - * Initialize this stack to be an exact copy of {s}. - */ - ACE_Unbounded_Stack (const ACE_Unbounded_Stack &s); - - /// Assignment operator (performs assignment). - /** - * Perform a deep copy of the rhs into the lhs. - */ - void operator= (const ACE_Unbounded_Stack &s); - - /// Perform actions needed when stack goes out of scope. - /** - * Destroy the underlying list for the stack. - */ - ~ACE_Unbounded_Stack (void); - - // = Classic Stack operations. - - - ///Push an element onto the top of stack. - /** - * Place a new item on top of the stack. Returns -1 if the stack - * is already full, 0 if the stack is not already full, and -1 if - * failure occurs. - */ - int push (const T &new_item); - - ///Pop the top element of the stack. - /** - * Remove and return the top stack item. Returns -1 if the stack is - * already empty, 0 if the stack is not already empty, and -1 if - * failure occurs. - */ - int pop (T &item); - - ///Examine the top of the stack. - /** - * Return top stack item without removing it. Returns -1 if the - * stack is already empty, 0 if the stack is not already empty, and - * -1 if failure occurs. - */ - int top (T &item) const; - - // = Check boundary conditions. - - /// Returns 1 if the container is empty, otherwise returns 0. - /** - * Constant time check to see if the stack is empty. - */ - int is_empty (void) const; - - /// Returns 1 if the container is full, otherwise returns 0. - /** - * Always resturns 0 since the stack is unbounded. - */ - int is_full (void) const; - - // = Auxiliary methods (not strictly part of the Stack ADT). - - ///Linear Insert of an item. - /** - * Insert {new_item} into the Stack at the head (but doesn't allow - * duplicates). Returns -1 if failures occur, 1 if item is already - * present (i.e., no duplicates are allowed), else 0. - */ - int insert (const T &new_item); - - /// Remove @a item from the Stack. Returns 0 if it removes the item, - /// -1 if it can't find the item, and -1 if a failure occurs. - /** - * Linear remove operation. - */ - int remove (const T &item); - - /// Finds if @a item occurs the set. Returns 0 if finds, else -1. - /** - * Linear find operation. - */ - int find (const T &item) const; - - /// The number of items in the stack. - /** - * Constant time access to the current stack size. - */ - size_t size (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Delete all the nodes in the stack. - void delete_all_nodes (void); - - /// Copy all nodes from {s} to {this}. - void copy_all_nodes (const ACE_Unbounded_Stack &s); - - /// Head of the linked list of Nodes. - ACE_Node *head_; - - /// Current size of the stack. - size_t cur_size_; - - /// Allocation strategy of the stack. - ACE_Allocator *allocator_; -}; - -/** - * @class ACE_Unbounded_Stack_Iterator - * - * @brief Implement an iterator over an unbounded Stack. - */ -template -class ACE_Unbounded_Stack_Iterator -{ -public: - /// Move to the first element in the {stack}. - ACE_Unbounded_Stack_Iterator (ACE_Unbounded_Stack &stack); - - // = Iteration methods. - - /// Pass back the @a next_item that hasn't been seen in the Stack. - /// Returns 0 when all items have been seen, else 1. - int next (T *&next_item); - - /// Move forward by one element in the Stack. Returns 0 when all the - /// items in the Stack have been seen, else 1. - int advance (void); - - /// Move to the first element in the Stack. Returns 0 if the - /// Stack is empty, else 1. - int first (void); - - /// Returns 1 when all items have been seen, else 0. - int done (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Pointer to the current node in the iteration. - ACE_Node *current_; - - /// Pointer to the Stack we're iterating over. - ACE_Unbounded_Stack &stack_; -}; - -template -class ACE_Double_Linked_List; - -/** - * @class ACE_Double_Linked_List_Iterator_Base - * - * @brief Implements a common base class for iterators for a double - * linked list ADT - */ -template -class ACE_Double_Linked_List_Iterator_Base -{ -public: - // = Iteration methods. - - /// Passes back the {entry} under the iterator. Returns 0 if the - /// iteration has completed, otherwise 1 - int next (T *&) const; - - /** - * @deprecated Return the address of next (current) unvisited item in - * the list. 0 if there is no more element available. - */ - T *next (void) const; - - /// Returns 1 when all items have been seen, else 0. - int done (void) const; - - /// STL-like iterator dereference operator: returns a reference - /// to the node underneath the iterator. - T & operator* (void) const ; - - /** - * Retasks the iterator to iterate over a new - * Double_Linked_List. This allows clients to reuse an iterator - * without incurring the constructor overhead. If you do use this, - * be aware that if there are more than one reference to this - * iterator, the other "clients" may be very bothered when their - * iterator changes. @@ Here be dragons. Comments? - */ - void reset (ACE_Double_Linked_List &); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Constructor - ACE_Double_Linked_List_Iterator_Base (const ACE_Double_Linked_List &); - - /// Copy constructor. - ACE_Double_Linked_List_Iterator_Base (const - ACE_Double_Linked_List_Iterator_Base - &iter); - - // = Iteration methods. - /** - * Move to the first element of the list. Returns 0 if the list is - * empty, else 1. - * @note the head of the ACE_DLList is actually a null entry, so the - * first element is actually the 2n'd entry - */ - int go_head (void); - - /// Move to the last element of the list. Returns 0 if the list is - /// empty, else 1. - int go_tail (void); - - /** - * Check if we reach the end of the list. Can also be used to get - * the *current* element in the list. Return the address of the - * current item if there are still elements left , 0 if we run out - * of element. - */ - T *not_done (void) const ; - - /// Advance to the next element in the list. Return the address of the - /// next element if there are more, 0 otherwise. - T *do_advance (void); - - /// Retreat to the previous element in the list. Return the address - /// of the previous element if there are more, 0 otherwise. - T *do_retreat (void); - - /// Dump the state of an object. - void dump_i (void) const; - - /// Remember where we are. - T *current_; - - const ACE_Double_Linked_List *dllist_; -}; - -/** - * @class ACE_Double_Linked_List_Iterator - * - * @brief Implements an iterator for a double linked list ADT - * - * Iterate thru the double-linked list. This class provides - * an interface that let users access the internal element - * addresses directly. Notice {class T} must declare - * ACE_Double_Linked_List<T>, - * ACE_Double_Linked_List_Iterator_Base <T> and - * ACE_Double_Linked_List_Iterator as friend classes and class T - * should also have data members T* next_ and T* prev_. - */ -template -class ACE_Double_Linked_List_Iterator : public ACE_Double_Linked_List_Iterator_Base -{ -public: - ACE_Double_Linked_List_Iterator (const ACE_Double_Linked_List &); - - /** - * Retasks the iterator to iterate over a new - * Double_Linked_List. This allows clients to reuse an iterator - * without incurring the constructor overhead. If you do use this, - * be aware that if there are more than one reference to this - * iterator, the other "clients" may be very bothered when their - * iterator changes. - * @@ Here be dragons. Comments? - */ - void reset (ACE_Double_Linked_List &); - - /// Move to the first element in the list. Returns 0 if the - /// list is empty, else 1. - int first (void); - - /// Move forward by one element in the list. Returns 0 when all the - /// items in the list have been seen, else 1. - int advance (void); - - /** - * Advance the iterator while removing the original item from the - * list. Return a pointer points to the original (removed) item. - * If @a dont_remove equals false, this function behaves like {advance} - * but return 0 (NULL) instead. - */ - T* advance_and_remove (bool dont_remove); - - // = STL-style iteration methods - - /// Prefix advance. - ACE_Double_Linked_List_Iterator & operator++ (void); - - /// Postfix advance. - ACE_Double_Linked_List_Iterator operator++ (int); - - /// Prefix reverse. - ACE_Double_Linked_List_Iterator & operator-- (void); - - /// Postfix reverse. - ACE_Double_Linked_List_Iterator operator-- (int); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -/** - * @class ACE_Double_Linked_List_Reverse_Iterator - * - * @brief Implements a reverse iterator for a double linked list ADT - * - * Iterate backwards over the double-linked list. This class - * provide an interface that let users access the internal - * element addresses directly, which seems to break the - * encapsulation. Notice {class T} must declare - * ACE_Double_Linked_List<T>, - * ACE_Double_Linked_List_Iterator_Base <T> and - * ACE_Double_Linked_List_Iterator as friend classes and class T - * should also have data members T* next_ and T* prev_. - */ -template -class ACE_Double_Linked_List_Reverse_Iterator : public ACE_Double_Linked_List_Iterator_Base -{ -public: - ACE_Double_Linked_List_Reverse_Iterator (ACE_Double_Linked_List &); - - /** - * Retasks the iterator to iterate over a new - * Double_Linked_List. This allows clients to reuse an iterator - * without incurring the constructor overhead. If you do use this, - * be aware that if there are more than one reference to this - * iterator, the other "clients" may be very bothered when their - * iterator changes. - * @@ Here be dragons. Comments? - */ - void reset (ACE_Double_Linked_List &); - - /// Move to the first element in the list. Returns 0 if the - /// list is empty, else 1. - int first (void); - - /// Move forward by one element in the list. Returns 0 when all the - /// items in the list have been seen, else 1. - int advance (void); - - /** - * Advance the iterator while removing the original item from the - * list. Return a pointer points to the original (removed) item. - * If @a dont_remove equals false, this function behaves like {advance} - * but return 0 (NULL) instead. - */ - T* advance_and_remove (bool dont_remove); - - // = STL-style iteration methods - - /// Prefix advance. - ACE_Double_Linked_List_Reverse_Iterator & operator++ (void); - - /// Postfix advance. - ACE_Double_Linked_List_Reverse_Iterator operator++ (int); - - /// Prefix reverse. - ACE_Double_Linked_List_Reverse_Iterator & operator-- (void); - - /// Postfix reverse. - ACE_Double_Linked_List_Reverse_Iterator operator-- (int); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - - -/** - * @class ACE_Double_Linked_List - * - * @brief A double-linked list implementation. - * - * This implementation of an unbounded double-linked list uses a - * circular linked list with a dummy node. It is pretty much - * like the {ACE_Unbounded_Queue} except that it allows removing - * of a specific element from a specific location. - * Notice that this class is an implementation of a very simple - * data structure. This is *NOT* a container class. You can use the - * class to implement other contains classes but it is *NOT* a - * general purpose container class. - * The parameter class *MUST* have members T* prev and T* next - * and users of this class are responsible to follow the general - * rules of using double-linked lists to maintaining the list - * integrity. - * If you need a double linked container class, use the DLList - * class which is a container but delegates to the Double_Linked_List - * class. - * - * Requirements and Performance Characteristics - * - Internal Structure - * Double Linked List - * - Duplicates allowed? - * Yes - * - Random access allowed? - * No - * - Search speed - * N/A - * - Insert/replace speed - * Linear - * - Iterator still valid after change to container? - * Yes - * - Frees memory for removed elements? - * No - * - Items inserted by - * Value - * - Requirements for contained type - * -# Default constructor - * -# Copy constructor - * -# operator= - */ -template -class ACE_Double_Linked_List -{ -public: - friend class ACE_Double_Linked_List_Iterator_Base; - friend class ACE_Double_Linked_List_Iterator; - friend class ACE_Double_Linked_List_Reverse_Iterator; - - // Trait definition. - typedef ACE_Double_Linked_List_Iterator ITERATOR; - typedef ACE_Double_Linked_List_Reverse_Iterator REVERSE_ITERATOR; - - /// construction. Use user specified allocation strategy - /// if specified. - /** - * Initialize an empy list using the allocation strategy specified by the user. - * If none is specified, then use default allocation strategy. - */ - ACE_Double_Linked_List (ACE_Allocator *the_allocator = 0); - - /// Copy constructor. - /** - * Create a double linked list that is a copy of the provided - * parameter. - */ - ACE_Double_Linked_List (const ACE_Double_Linked_List &); - - /// Assignment operator. - /** - * Perform a deep copy of the provided list by first deleting the nodes of the - * lhs and then copying the nodes of the rhs. - */ - void operator= (const ACE_Double_Linked_List &); - - /// Destructor. - /** - * Clean up the memory allocated for the nodes of the list. - */ - ~ACE_Double_Linked_List (void); - - // = Check boundary conditions. - - /// Returns 1 if the container is empty, 0 otherwise. - /** - * Performs constant time check to determine if the list is empty. - */ - int is_empty (void) const; - - /// The list is unbounded, so this always returns 0. - /** - * Since the list is unbounded, the method simply returns 0. - */ - int is_full (void) const; - - // = Classic queue operations. - - /// Adds @a new_item to the tail of the list. Returns the new item - /// that was inserted. - /** - * Provides constant time insertion at the end of the list structure. - */ - T *insert_tail (T *new_item); - - /// Adds @a new_item to the head of the list.Returns the new item that - /// was inserted. - /** - * Provides constant time insertion at the head of the list. - */ - T *insert_head (T *new_item); - - /// Removes the head of the list and returns a pointer to that item. - /** - * Removes and returns the first {item} in the list. Returns - * internal node's address on success, 0 if the queue was empty. - * This method will *not* free the internal node. - */ - T* delete_head (void); - - /// Removes the tail of the list and returns a pointer to that item. - /** - * Removes and returns the last {item} in the list. Returns - * internal nodes's address on success, 0 if the queue was - * empty. This method will *not* free the internal node. - */ - T *delete_tail (void); - - // = Additional utility methods. - - ///Empty the list. - /** - * Reset the {ACE_Double_Linked_List} to be empty. - * Notice that since no one is interested in the items within, - * This operation will delete all items. - */ - void reset (void); - - /// Get the {slot}th element in the set. Returns -1 if the element - /// isn't in the range {0..{size} - 1}, else 0. - /** - * Iterates through the list to the desired index and assigns the provides pointer - * with the address of the node occupying that index. - */ - int get (T *&item, size_t slot = 0); - - /// The number of items in the queue. - /** - * Constant time call to return the current size of the list. - */ - size_t size (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Use DNode address directly. - /** - * Constant time removal of an item from the list using it's address. - */ - int remove (T *n); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Delete all the nodes in the list. - /** - * Removes and deallocates memory for all of the list nodes. - */ - void delete_nodes (void); - - /// Copy nodes from {rhs} into this list. - /** - * Copy the elements of the provided list by allocated new nodes and assigning - * them with the proper data. - */ - void copy_nodes (const ACE_Double_Linked_List &rhs); - - /// Setup header pointer. Called after we create the head node in ctor. - /** - * Initialize the head pointer so that the list has a dummy node. - */ - void init_head (void); - - ///Constant time insert a new item into the list structure. - /** - * Insert a @a new_item into the list. It will be added before - * or after @a old_item. Default is to insert the new item *after* - * {head_}. Return 0 if succeed, -1 if error occurred. - */ - int insert_element (T *new_item, - int before = 0, - T *old_item = 0); - - ///Constant time delete an item from the list structure. - /** - * Remove @a item from the list. Return 0 if succeed, -1 otherwise. - * Notice that this function checks if item is {head_} and either its - * {next_} or {prev_} is NULL. The function resets item's {next_} and - * {prev_} to 0 to prevent clobbering the double-linked list if a user - * tries to remove the same node again. - */ - int remove_element (T *item); - - /// Head of the circular double-linked list. - T *head_; - - /// Size of this list. - size_t size_; - - /// Allocation Strategy of the queue. - ACE_Allocator *allocator_; -}; - - -template class ACE_DLList; -template class ACE_DLList_Iterator; -template class ACE_DLList_Reverse_Iterator; - -typedef ACE_Double_Linked_List ACE_DLList_Base; - -//typedef ACE_Double_Linked_List_Iterator -// ACE_DLList_Iterator_Base; -//typedef ACE_Double_Linked_List_Reverse_Iterator -// ACE_DLList_Reverse_Iterator_Base; -//@@ These two typedefs (inherited from James Hu's original design) -// have been removed because Sun CC 4.2 had problems with it. I guess -// having the DLList_Iterators inheriting from a class which is -// actually a typedef leads to problems. #define'ing rather than -// typedef'ing worked, but as per Carlos's reccomendation, I'm just -// replacing all references to the base classes with their actual -// type. Matt Braun (6/15/99) - -/** - * @class ACE_DLList - * - * @brief A double-linked list container class. - * - * ACE_DLList is a simple, unbounded container implemented using a - * double-linked list. It is critical to remember that ACE_DLList inherits - * from ACE_Double_Linked_List, wrapping each T pointer in a ACE_DLList_Node - * object which satisfies the next/prev pointer requirements imposed by - * ACE_Double_Linked_List. - * - * Each item inserted to an ACE_DLList is a pointer to a T object. The - * caller is responsible for lifetime of the T object. ACE_DLList takes no - * action on the T object; it is not copied on insertion and it is not - * deleted on removal from the ACE_DLList. - */ -template -class ACE_DLList : public ACE_DLList_Base -{ - friend class ACE_DLList_Node; - friend class ACE_Double_Linked_List_Iterator; - friend class ACE_DLList_Iterator; - friend class ACE_DLList_Reverse_Iterator; - -public: - /// Delegates to ACE_Double_Linked_List. - void operator= (const ACE_DLList &l); - - /** - * @name Queue-like insert and delete methods - */ - //@{ - - /** - * Insert pointer for a new item at the tail of the list. - * - * @return Pointer to item inserted; 0 on error. - */ - T *insert_tail (T *new_item); - - /** - * Insert pointer for a new item at the head of the list. - * - * @return Pointer to item inserted; 0 on error. - */ - T *insert_head (T *new_item); - - /** - * Removes the item at the head of the list and returns its pointer. - * - * @return Pointer to previously inserted item; 0 if the list is empty, - * an error occurred, or the original pointer inserted was 0. - */ - T *delete_head (void); - - /** - * Removes the item at the tail of the list and returns its pointer. - * - * @return Pointer to previously inserted item; 0 if the list is empty, - * an error occurred, or the original pointer inserted was 0. - */ - T *delete_tail (void); - //@} - - /** - * Provide random access to any item in the list. - * - * @param item Receives a pointer to the T object pointer held at the - * specified position in the list. - * @param slot Position in the list to access. The first position is 0. - * - * @retval 0 Success; T pointer returned in item. - * @retval -1 Error, most likely slot is outside the range of the list. - */ - int get (T *&item, size_t slot = 0); - - /// Delegates to ACE_Double_Linked_List. - void dump (void) const; - - /// Delegates to ACE_Double_Linked_List. - int remove (ACE_DLList_Node *n); - - /** - * Constructor. - * - * @param the_allocator Allocator to use for allocating ACE_DLList_Node - * objects that wrap T objects for inclusion in the - * list. If 0, ACE_Allocator::instance() is used. - */ - ACE_DLList (ACE_Allocator *the_allocator = 0); - - /// Delegates to ACE_Double_Linked_List. - ACE_DLList (const ACE_DLList &l); - - /** - * Deletes all ACE_DLList_Node objects in the list starting from the head. - * No T objects referred to by the deleted ACE_DLList_Node objects are - * modified or freed. If you desire all of the T objects in the list to - * be deleted as well, code such as this should be used prior to destroying - * the ACE_DLList: - * @code - ACE_DLList list; - ... // insert dynamically allocated Items... - Item *p; - while ((p = list.delete_head()) != 0) - delete *p; - @endcode - */ - ~ACE_DLList (void); -}; - -/** - * @class ACE_DLList_Iterator - * - * @brief A double-linked list container class iterator. - * - * This implementation uses ACE_Double_Linked_List_Iterator to - * perform the logic behind this container class. It delegates - * all of its calls to ACE_Double_Linked_List_Iterator. - */ -template -class ACE_DLList_Iterator : public ACE_Double_Linked_List_Iterator -{ - friend class ACE_DLList; - friend class ACE_DLList_Node; - -public: - ACE_DLList_Iterator (ACE_DLList &l); - - /** - * Retasks the iterator to iterate over a new - * Double_Linked_List. This allows clients to reuse an iterator - * without incurring the constructor overhead. If you do use this, - * be aware that if there are more than one reference to this - * iterator, the other "clients" may be very bothered when their - * iterator changes. - * @@ Here be dragons. Comments? - */ - void reset (ACE_DLList &l); - - // = Iteration methods. - /// Move forward by one element in the list. Returns 0 when all the - /// items in the list have been seen, else 1. - int advance (void); - - /// Pass back the {next_item} that hasn't been seen in the list. - /// Returns 0 when all items have been seen, else 1. - int next (T *&); - - /** - * @deprecated Delegates to ACE_Double_Linked_List_Iterator, except that - * whereas the Double_Linked_List version of next returns the node, this next - * returns the contents of the node - */ - T *next (void) const; - - /** - * Removes the current item (i.e., {next}) from the list. - * Note that DLList iterators do not support {advance_and_remove} - * directly (defined in its base class) and you will need to - * release the element returned by it. - */ - int remove (void); - - /// Delegates to ACE_Double_Linked_List_Iterator. - void dump (void) const; - -private: - ACE_DLList *list_; -}; - -/** - * @class ACE_DLList_Reverse_Iterator - * - * @brief A double-linked list container class iterator. - * - * This implementation uses ACE_Double_Linked_List_Iterator to - * perform the logic behind this container class. It delegates - * all of its calls to ACE_Double_Linked_List_Iterator. - */ -template -class ACE_DLList_Reverse_Iterator : public ACE_Double_Linked_List_Reverse_Iterator -{ - friend class ACE_DLList; - friend class ACE_DLList_Node; - -public: - ACE_DLList_Reverse_Iterator (ACE_DLList &l); - - /** - * Retasks the iterator to iterate over a new - * Double_Linked_List. This allows clients to reuse an iterator - * without incurring the constructor overhead. If you do use this, - * be aware that if there are more than one reference to this - * iterator, the other "clients" may be very bothered when their - * iterator changes. - * @@ Here be dragons. Comments? - */ - void reset (ACE_DLList &l); - - // = Iteration methods. - /// Move forward by one element in the list. Returns 0 when all the - /// items in the list have been seen, else 1. - int advance (void); - - /// Pass back the {next_item} that hasn't been seen in the list. - /// Returns 0 when all items have been seen, else 1. - int next (T *&); - - /// @deprecated Delegates to ACE_Double_Linked_List_Iterator. - T *next (void) const; - - /// Removes the current item (i.e., {next}) from the list. - /// Note that DLList iterators do not support {advance_and_remove} - /// directly (defined in its base class) and you will need to - /// release the element returned by it. - int remove (void); - - /// Delegates to ACE_Double_Linked_List_Iterator. - void dump (void) const; - -private: - ACE_DLList *list_; -}; - -// Forward declaration. -template -class ACE_Fixed_Set; - -/** - * @class ACE_Fixed_Set_Iterator_Base - * - * @brief Implements a common base class for iterators for a unordered set. - */ -template -class ACE_Fixed_Set_Iterator_Base -{ -public: - // = Iteration methods. - - /// Pass back the {next_item} that hasn't been seen in the Set. - /// Returns 0 when all items have been seen, else 1. - int next (T *&next_item); - - /// Move forward by one element in the set. Returns 0 when all the - /// items in the set have been seen, else 1. - int advance (void); - - /// Move to the first element in the set. Returns 0 if the - /// set is empty, else 1. - int first (void); - - /// Returns 1 when all items have been seen, else 0. - int done (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - ACE_Fixed_Set_Iterator_Base (ACE_Fixed_Set &s); - - /// Set we are iterating over. - ACE_Fixed_Set &s_; - - /// How far we've advanced over the set. - ssize_t next_; - - /// The number of non free items that the iterator had pointed at. - size_t iterated_items_; - - /// Dump the state of an object. - void dump_i (void) const; - - /// Pass back the {next_item} that hasn't been seen in the Set. - /// Returns 0 when all items have been seen, else 1. - int next_i (T *&next_item); -}; - -/** - * @class ACE_Fixed_Set_Iterator - * - * @brief Iterates through an unordered set. - * - * This implementation of an unordered set uses a fixed array. - * Allows deletions while iteration is occurring. - */ -template -class ACE_Fixed_Set_Iterator : public ACE_Fixed_Set_Iterator_Base -{ -public: - ACE_Fixed_Set_Iterator (ACE_Fixed_Set &s); - - // = Iteration methods. - - /// Pass back the {next_item} that hasn't been seen in the Set. - /// Returns 0 when all items have been seen, else 1. - int next (T *&next_item); - - /// Dump the state of an object. - void dump (void) const; - - /// Remove the item where the itearetor is located at. - /// Returns 1 if it removes a item, else 0. - /// Pass back the removed {item}. - int remove (T *&item); - - /// STL-like iterator dereference operator: returns a reference - /// to the node underneath the iterator. - T & operator* (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -/** - * @class ACE_Fixed_Set_Const_Iterator - * - * @brief Iterates through a const unordered set. - * - * This implementation of an unordered set uses a fixed array. - */ -template -class ACE_Fixed_Set_Const_Iterator : public ACE_Fixed_Set_Iterator_Base -{ -public: - ACE_Fixed_Set_Const_Iterator (const ACE_Fixed_Set &s); - - // = Iteration methods. - - /// Pass back the {next_item} that hasn't been seen in the Set. - /// Returns 0 when all items have been seen, else 1. - int next (const T *&next_item); - - /// Dump the state of an object. - void dump (void) const; - - /// STL-like iterator dereference operator: returns a reference - /// to the node underneath the iterator. - const T & operator* (void) const ; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -/** - * @class ACE_Fixed_Set - * - * @brief Implement a simple unordered set of {T} with maximum {ACE_SIZE}. - * - * This implementation of an unordered set uses a fixed array. - * It does not allow duplicate members. The set provides linear insertion/deletion - * operations. - * - * Requirements and Performance Characteristics - * - Internal Structure - * Fixed array - * - Duplicates allowed? - * No - * - Random access allowed? - * No - * - Search speed - * Linear - * - Insert/replace speed - * Linear - * - Iterator still valid after change to container? - * Yes - * - Frees memory for removed elements? - * No - * - Items inserted by - * Value - * - Requirements for contained type - * -# Default constructor - * -# Copy constructor - * -# operator= - * -# operator== - */ -template -class ACE_Fixed_Set -{ -public: - friend class ACE_Fixed_Set_Iterator_Base; - friend class ACE_Fixed_Set_Iterator; - friend class ACE_Fixed_Set_Const_Iterator; - - // Trait definitions. - typedef ACE_Fixed_Set_Iterator ITERATOR; - typedef ACE_Fixed_Set_Const_Iterator CONST_ITERATOR; - - /// Default Constructor. - /** - * Creates an empy set - */ - ACE_Fixed_Set (void); - - /// Copy constructor. - /** - * Initializes a set to be a copy of the set parameter. - */ - ACE_Fixed_Set (const ACE_Fixed_Set &); - - /// Assignment operator. - /** - * Deep copy of one set to another. - */ - void operator= (const ACE_Fixed_Set &); - - /// Destructor. - /** - * Destroys a set. - */ - ~ACE_Fixed_Set (void); - - // = Check boundary conditions. - - /// Returns 1 if the container is empty, otherwise returns 0. - /** - * Performs constant time check to determine if a set is empty. - */ - int is_empty (void) const; - - /// Returns 1 if the container is full, otherwise returns 0. - /** - * Performs a constant time check to see if the set is full. - */ - int is_full (void) const; - - // = Classic unordered set operations. - - ///Linear time insertion of an item unique to the set. - /** - * Insert @a new_item into the set (doesn't allow duplicates). - * Returns -1 if failures occur, 1 if item is already present, else - * 0. - */ - int insert (const T &new_item); - - ///Linear time removal operation of an item. - /** - * Remove first occurrence of {item} from the set. Returns 0 if - * it removes the item, -1 if it can't find the item, and -1 if a - * failure occurs. Removal doesn't reclaim memory for the @a item. - */ - int remove (const T &item); - - /// Finds if @a item occurs in the set. Returns 0 if finds, else -1. - /** - * Performs a linear find operation for the specified @a item. - */ - int find (const T &item) const; - - /// Size of the set. - /** - * Returns the current size of the set. - */ - size_t size (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Holds the contents of the set. - struct - { - /// Item in the set. - T item_; - - /// Keeps track of whether this item is in use or not. - int is_free_; - } search_structure_[ACE_SIZE]; - - /// Current size of the set. - size_t cur_size_; - - /// Maximum size of the set. - size_t max_size_; -}; - -// Forward declaration. -template -class ACE_Bounded_Set; - -/** - * @class ACE_Bounded_Set_Iterator - * - * @brief Iterates through an unordered set. - * - * This implementation of an unordered set uses a Bounded array. - * Allows deletions while iteration is occurring. - */ -template -class ACE_Bounded_Set_Iterator -{ -public: - ACE_Bounded_Set_Iterator (ACE_Bounded_Set &s); - - // = Iteration methods. - - /// Pass back the {next_item} that hasn't been seen in the Set. - /// Returns 0 when all items have been seen, else 1. - int next (T *&next_item); - - /// Move forward by one element in the set. Returns 0 when all the - /// items in the set have been seen, else 1. - int advance (void); - - /// Move to the first element in the set. Returns 0 if the - /// set is empty, else 1. - int first (void); - - /// Returns 1 when all items have been seen, else 0. - int done (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Set we are iterating over. - ACE_Bounded_Set &s_; - - /// How far we've advanced over the set. - ssize_t next_; -}; - - -/** - * @class ACE_Bounded_Set - * - * @brief Implement a simple unordered set of {T} with maximum - * set at creation time. - * - * This implementation of an unordered set uses a Bounded array. - * This implementation does not allow duplicates. It provides - * linear insert/remove/find operations. Insertion/removal does not - * invalidate iterators, but caution should be taken to ensure - * expected behavior. Once initialized, the object has a maximum size - * which can only be increased by the assignment of another larger Bounded_Set. - * - * Requirements and Performance Characteristics - * - Internal Structure - * Bounded array which can grow via assignment - * - Duplicates allowed? - * No - * - Random access allowed? - * No - * - Search speed - * Linear - * - Insert/replace speed - * Linear - * - Iterator still valid after change to container? - * Yes - * - Frees memory for removed elements? - * No - * - Items inserted by - * Value - * - Requirements for contained type - * -# Default constructor - * -# Copy constructor - * -# operator= - * -# operator== - */ -template -class ACE_Bounded_Set -{ -public: - friend class ACE_Bounded_Set_Iterator; - - // Trait definition. - typedef ACE_Bounded_Set_Iterator ITERATOR; - - enum - { - DEFAULT_SIZE = 10 - }; - - /// Construct a Bounded_Set using the default size. - /** - * The default constructor initializes the Bounded_Set to a maximum size - * specified by the DEFAULT_SIZE. - */ - ACE_Bounded_Set (void); - - /// Construct a Bounded_Set with the provided sizeB. - /** - * Initialize the Bounded_Set to have a maximum size equal to the size - * parameter specified. - */ - ACE_Bounded_Set (size_t size); - - /// Construct a Bounded_Set that is a copy of the provides Bounded_Set. - /** - * Initialize the Bounded_Set to be a copy of the Bounded_Set parameter. - */ - ACE_Bounded_Set (const ACE_Bounded_Set &); - - /// Assignment operator. - /** - * The assignment will make a deep copy of the Bounded_Set provided. If the - * rhs has more elements than the capacity of the lhs, then the lhs will be - * deleted and reallocated to accomadate the larger number of elements. - */ - void operator= (const ACE_Bounded_Set &); - - /// Destructor - /** - * Clean up the underlying dynamically allocated memory that is used by - * the Bounded_Set. - */ - ~ACE_Bounded_Set (void); - - // = Check boundary conditions. - - /// Returns 1 if the container is empty, otherwise returns 0. - /** - * A constant time check is performed to determine if the Bounded_Set is - * empty. - */ - int is_empty (void) const; - - /// Returns 1 if the container is full, otherwise returns 0. - /** - * Performs a constant time check to determine if the Bounded_Set is at - * capacity. - */ - int is_full (void) const; - - // = Classic unordered set operations. - - ///Inserts a new element unique to the set. - /** - * Insert @a new_item into the set (doesn't allow duplicates) in linear - * time. - * Returns -1 if failures occur, 1 if item is already present, else - * 0. - */ - int insert (const T &new_item); - - ///Finds the specified element and removes it from the set. - /** - * Remove first occurrence of @a item from the set. Returns 0 if it - * removes the item, -1 if it can't find the item, and -1 if a - * failure occurs. The linear remove operation does not reclaim the - * memory associated with the removed item. - */ - int remove (const T &item); - - /// Finds if @a item occurs in the set. Returns 0 if finds, else -1. - /** - * find preforms a linear search for {item} and returns 0 on successful - * find and -1 otherwise. - */ - int find (const T &item) const; - - /// Size of the set. - /** - * Returns a size_t representing the current size of the set. - */ - size_t size (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - struct Search_Structure - { - /// Item in the set. - T item_; - - /// Keeps track of whether this item is in use or not. - int is_free_; - }; - - /// Holds the contents of the set. - Search_Structure *search_structure_; - - /// Current size of the set. - size_t cur_size_; - - /// Maximum size of the set. - size_t max_size_; -}; - -/** - * @class ACE_Ordered_MultiSet_Iterator - * - * @brief Implement a bidirectional iterator over an ordered multiset. - * This class template requires that < operator semantics be - * defined for the parameterized type {T}, but does not impose - * any restriction on how that ordering operator is implemented. - */ -template -class ACE_Ordered_MultiSet_Iterator -{ -public: - friend class ACE_Ordered_MultiSet; - - ACE_Ordered_MultiSet_Iterator (ACE_Ordered_MultiSet &s); - - // = Iteration methods. - - /// Pass back the {next_item} that hasn't been seen in the ordered multiset. - /// Returns 0 when all items have been seen, else 1. - int next (T *&next_item) const; - - /// Repositions the iterator at the first item in the ordered multiset - /// Returns 0 if the list is empty else 1. - int first (void); - - /// Repositions the iterator at the last item in the ordered multiset - /// Returns 0 if the list is empty else 1. - int last (void); - - /// Move forward by one element in the set. Returns 0 when all the - /// items in the set have been seen, else 1. - int advance (void); - - /// Move backward by one element in the set. Returns 0 when all the - /// items in the set have been seen, else 1. - int retreat (void); - - /// Returns 1 when all items have been seen, else 0. - int done (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Returns a reference to the internal element {this} is pointing to. - T& operator* (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Pointer to the current node in the iteration. - ACE_DNode *current_; - - /// Pointer to the set we're iterating over. - ACE_Ordered_MultiSet &set_; -}; - - -/** - * @class ACE_Ordered_MultiSet - * - * @brief Implement a simple ordered multiset of {T} of unbounded size - * that allows duplicates. This class template requires that < - * operator semantics be defined for the parameterized type {T}, but - * does not impose any restriction on how that ordering operator is - * implemented. The set is implemented as a linked list. - * - * Requirements and Performance Characteristics - * - Internal Structure - * Double linked list - * - Duplicates allowed? - * Yes - * - Random access allowed? - * No - * - Search speed - * Linear - * - Insert/replace speed - * Linear - * - Iterator still valid after change to container? - * Yes - * - Frees memory for removed elements? - * Yes - * - Items inserted by - * Value - * - Requirements for contained type - * -# Default constructor - * -# Copy constructor - * -# operator= - * -# operator== - * -# operator< - */ -template -class ACE_Ordered_MultiSet -{ -public: - friend class ACE_Ordered_MultiSet_Iterator; - - // Trait definition. - typedef ACE_Ordered_MultiSet_Iterator ITERATOR; - - /// Constructor. Use user specified allocation strategy - /// if specified. - /** - * Initialize the set using the allocation strategy specified. If none, use the - * default strategy. - */ - ACE_Ordered_MultiSet (ACE_Allocator *the_allocator = 0); - - /// Copy constructor. - /** - * Initialize the set to be a copy of the provided set. - */ - ACE_Ordered_MultiSet (const ACE_Ordered_MultiSet &); - - /// Destructor. - /** - * Delete the nodes of the set. - */ - ~ACE_Ordered_MultiSet (void); - - /// Assignment operator. - /** - * Delete the nodes in lhs, and copy the nodes from the rhs. - */ - void operator= (const ACE_Ordered_MultiSet &); - - // = Check boundary conditions. - - /// Returns 1 if the container is empty, otherwise returns 0. - /** - * Constant time check to determine if the set is empty. - */ - int is_empty (void) const; - - /// Size of the set. - /** - * Constant time check to determine the size of the set. - */ - size_t size (void) const; - - // = Classic unordered set operations. - - /// Insert @a new_item into the ordered multiset. - /// Returns -1 if failures occur, else 0. - /** - * Linear time, order preserving insert into the set beginning at the head. - */ - int insert (const T &new_item); - - ///Linear time insert beginning at the point specified by the provided iterator. - /** - * Insert @a new_item into the ordered multiset, starting its search at - * the node pointed to by the iterator, and if insertion was successful, - * updates the iterator to point to the newly inserted node. - * Returns -1 if failures occur, else 0. - */ - int insert (const T &new_item, ITERATOR &iter); - - /// Remove first occurrence of @a item from the set. Returns 0 if - /// it removes the item, -1 if it can't find the item. - /** - * Linear time search operation which removes the item from the set if found . - */ - int remove (const T &item); - - ///Linear find operation. - /** - * Finds first occurrence of @a item in the multiset, using the iterator's - * current position as a hint to improve performance. If find succeeds, - * it positions the iterator at that node and returns 0, or if it cannot - * locate the node, it leaves the iterator alone and just returns -1. - */ - int find (const T &item, ITERATOR &iter) const; - - /// Reset the ACE_Ordered_MultiSet to be empty. - /** - * Delete the nodes inside the set. - */ - void reset (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /** - * Insert @a item, starting its search at the position given, - * and if successful updates the passed pointer to point to - * the newly inserted item's node. - */ - int insert_from (const T &item, ACE_DNode *start_position, - ACE_DNode **new_position); - - /** - * Looks for first occurrence of @a item in the ordered set, using the - * passed starting position as a hint: if there is such an instance, it - * updates the new_position pointer to point to this node and returns 0; - * if there is no such node, then if there is a node before where the - * item would have been, it updates the new_position pointer to point - * to this node and returns -1; if there is no such node, then if there - * is a node after where the item would have been, it updates the - * new_position pointer to point to this node (or 0 if there is no such - * node) and returns 1; - */ - int locate (const T &item, ACE_DNode *start_position, - ACE_DNode *&new_position) const; - - /// Delete all the nodes in the Set. - void delete_nodes (void); - - /// Copy nodes into this set. - void copy_nodes (const ACE_Ordered_MultiSet &); - - /// Head of the bilinked list of Nodes. - ACE_DNode *head_; - - /// Head of the bilinked list of Nodes. - ACE_DNode *tail_; - - /// Current size of the set. - size_t cur_size_; - - /// Allocation strategy of the set. - ACE_Allocator *allocator_; -}; - -// **************************************************************** - -/** - * @class ACE_Array - * - * @brief A dynamic array class. - * - * This class extends ACE_Array_Base, adding comparison operators. - * - * Requirements and Performance Characteristics - * - Internal Structure - * Dynamic array - * - Duplicates allowed? - * Yes - * - Random access allowed? - * Yes - * - Search speed - * N/A - * - Insert/replace speed - * O(1) - * - Iterator still valid after change to container? - * - In general, yes. - * - If array size is changed during iteration, no. - * - Frees memory for removed elements? - * No - * - Items inserted by - * Value - * - Requirements for contained type - * -# Default constructor - * -# Copy constructor - * -# operator= - * -# operator!= - * - * @sa ACE_Array_Base. This class inherits its operations and requirements. - */ -template -class ACE_Array : public ACE_Array_Base -{ -public: - // Define a "trait" - typedef T TYPE; - typedef ACE_Array_Iterator ITERATOR; - - /// Dynamically create an uninitialized array. - /** - * Initialize an empty array of the specified size using the provided - * allocation strategy. - */ - ACE_Array (size_t size = 0, - ACE_Allocator* alloc = 0); - - /// Dynamically initialize the entire array to the {default_value}. - /** - * Initialize an array the given size placing the default_value in each index. - */ - ACE_Array (size_t size, - const T &default_value, - ACE_Allocator* alloc = 0); - - ///Copy constructor. - /** - * The copy constructor performs initialization by making an exact - * copy of the contents of parameter {s}, i.e., *this == s will - * return true. - */ - ACE_Array (const ACE_Array &s); - - ///Assignment operator - /** - * Assignment operator performs an assignment by making an exact - * copy of the contents of parameter {s}, i.e., *this == s will - * return true. Note that if the {max_size_} of {array_} is >= than - * {s.max_size_} we can copy it without reallocating. However, if - * {max_size_} is < {s.max_size_} we must delete the {array_}, - * reallocate a new {array_}, and then copy the contents of {s}. - */ - void operator= (const ACE_Array &s); - - // = Compare operators - - ///Equality comparison operator. - /** - * Compare this array with {s} for equality. Two arrays are equal - * if their {size}'s are equal and all the elements from 0 .. {size} - * are equal. - */ - bool operator== (const ACE_Array &s) const; - - ///Inequality comparison operator. - /** - * Compare this array with {s} for inequality such that {*this} != - * {s} is always the complement of the boolean return value of - * {*this} == {s}. - */ - bool operator!= (const ACE_Array &s) const; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Containers_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Containers_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Containers_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_CONTAINERS_T_H */ diff --git a/deps/acelite/ace/Containers_T.inl b/deps/acelite/ace/Containers_T.inl deleted file mode 100644 index adc0f42cd..000000000 --- a/deps/acelite/ace/Containers_T.inl +++ /dev/null @@ -1,476 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE int -ACE_Bounded_Stack::is_empty (void) const -{ - ACE_TRACE ("ACE_Bounded_Stack::is_empty"); - return this->top_ == 0; -} - -template ACE_INLINE int -ACE_Bounded_Stack::is_full (void) const -{ - ACE_TRACE ("ACE_Bounded_Stack::is_full"); - return this->top_ >= this->size_; -} - -template ACE_INLINE int -ACE_Bounded_Stack::push (const T &new_item) -{ - ACE_TRACE ("ACE_Bounded_Stack::push"); - if (this->is_full () == 0) - { - this->stack_[this->top_++] = new_item; - return 0; - } - else - return -1; -} - -template ACE_INLINE int -ACE_Bounded_Stack::pop (T &item) -{ - ACE_TRACE ("ACE_Bounded_Stack::pop"); - if (this->is_empty () == 0) - { - item = this->stack_[--this->top_]; - return 0; - } - else - return -1; -} - -template ACE_INLINE int -ACE_Bounded_Stack::top (T &item) const -{ - ACE_TRACE ("ACE_Bounded_Stack::top"); - if (this->is_empty () == 0) - { - item = this->stack_[this->top_ - 1]; - return 0; - } - else - return -1; -} - -template ACE_INLINE size_t -ACE_Bounded_Stack::size (void) const -{ - return this->size_; -} - -//---------------------------------------- - -template ACE_INLINE int -ACE_Fixed_Stack::is_empty (void) const -{ - ACE_TRACE ("ACE_Fixed_Stack::is_empty"); - return this->top_ == 0; -} - -template ACE_INLINE int -ACE_Fixed_Stack::is_full (void) const -{ - ACE_TRACE ("ACE_Fixed_Stack::is_full"); - return this->top_ >= this->size_; -} - -template ACE_INLINE int -ACE_Fixed_Stack::push (const T &new_item) -{ - ACE_TRACE ("ACE_Fixed_Stack::push"); - if (this->is_full () == 0) - { - this->stack_[this->top_++] = new_item; - return 0; - } - else - return -1; -} - -template ACE_INLINE int -ACE_Fixed_Stack::pop (T &item) -{ - ACE_TRACE ("ACE_Fixed_Stack::pop"); - if (this->is_empty () == 0) - { - item = this->stack_[--this->top_]; - return 0; - } - else - return -1; -} - -template ACE_INLINE int -ACE_Fixed_Stack::top (T &item) const -{ - ACE_TRACE ("ACE_Fixed_Stack::top"); - if (this->is_empty () == 0) - { - item = this->stack_[this->top_ - 1]; - return 0; - } - else - return -1; -} - -template ACE_INLINE size_t -ACE_Fixed_Stack::size (void) const -{ - return this->size_; -} - -template ACE_INLINE int -ACE_Unbounded_Stack::is_empty (void) const -{ - // ACE_TRACE ("ACE_Unbounded_Stack::is_empty"); - return this->head_ == this->head_->next_; -} - -template ACE_INLINE int -ACE_Unbounded_Stack::top (T &item) const -{ - ACE_TRACE ("ACE_Unbounded_Stack::top"); - if (this->is_empty () == 0) - { - item = this->head_->next_->item_; - return 0; - } - else - return -1; -} - -template ACE_INLINE int -ACE_Unbounded_Stack::is_full (void) const -{ - ACE_TRACE ("ACE_Unbounded_Stack::is_full"); - return 0; // ??? -} - -template ACE_INLINE size_t -ACE_Unbounded_Stack::size (void) const -{ - return this->cur_size_; -} - -// --- - - -// --- - -template ACE_INLINE int -ACE_Fixed_Set::is_empty (void) const -{ - ACE_TRACE ("ACE_Fixed_Set::is_empty"); - return this->cur_size_ == 0; -} - -template ACE_INLINE int -ACE_Fixed_Set::is_full (void) const -{ - ACE_TRACE ("ACE_Fixed_Set::is_full"); - return this->cur_size_ == this->max_size_; -} - -// --- - -template ACE_INLINE int -ACE_Bounded_Set::is_empty (void) const -{ - ACE_TRACE ("ACE_Bounded_Set::is_empty"); - return this->cur_size_ == 0; -} - -template ACE_INLINE int -ACE_Bounded_Set::is_full (void) const -{ - ACE_TRACE ("ACE_Bounded_Set::is_full"); - return this->cur_size_ == this->max_size_; -} - -// -- - -template ACE_INLINE int -ACE_Ordered_MultiSet_Iterator::first (void) -{ - ACE_TRACE ("ACE_Ordered_MultiSet_Iterator::first"); - current_ = set_.head_; - - return (current_ ? 1 : 0); -} - -template ACE_INLINE int -ACE_Ordered_MultiSet_Iterator::last (void) -{ - ACE_TRACE ("ACE_Ordered_MultiSet_Iterator::last"); - current_ = set_.tail_; - - return (current_ ? 1 : 0); -} - -template ACE_INLINE int -ACE_Ordered_MultiSet_Iterator::advance (void) -{ - ACE_TRACE ("ACE_Ordered_MultiSet_Iterator::advance"); - - current_ = current_ ? current_->next_ : 0; - - return (current_ ? 1 : 0); -} - -template ACE_INLINE int -ACE_Ordered_MultiSet_Iterator::retreat (void) -{ - ACE_TRACE ("ACE_Ordered_MultiSet_Iterator::retreat"); - - current_ = current_ ? current_->prev_ : 0; - - return (current_ ? 1 : 0); -} - -template ACE_INLINE int -ACE_Ordered_MultiSet_Iterator::done (void) const -{ - ACE_TRACE ("ACE_Ordered_MultiSet_Iterator::done"); - - return (current_ ? 0 : 1); -} - -template ACE_INLINE void -ACE_Ordered_MultiSet_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Ordered_MultiSet_Iterator::dump"); -#endif /* ACE_HAS_DUMP */ -} - - - -// -- - -template ACE_INLINE int -ACE_Ordered_MultiSet::is_empty (void) const -{ - ACE_TRACE ("ACE_Ordered_MultiSet::is_empty"); - return this->cur_size_ > 0 ? 0 : 1; -} - -template ACE_INLINE size_t -ACE_Ordered_MultiSet::size (void) const -{ -// ACE_TRACE ("ACE_Ordered_MultiSet::size"); - return this->cur_size_; -} - -// **************************************************************** - -template ACE_INLINE -ACE_Array::ACE_Array (size_t size, - ACE_Allocator *alloc) - : ACE_Array_Base (size, alloc) -{ -} - -template ACE_INLINE -ACE_Array::ACE_Array (size_t size, - const T &default_value, - ACE_Allocator *alloc) - : ACE_Array_Base (size, default_value, alloc) -{ -} - -// The copy constructor (performs initialization). - -template ACE_INLINE -ACE_Array::ACE_Array (const ACE_Array &s) - : ACE_Array_Base (s) -{ -} - -// Assignment operator (performs assignment). - -template ACE_INLINE void -ACE_Array::operator= (const ACE_Array &s) -{ - // Check for "self-assignment". - - if (this != &s) - this->ACE_Array_Base::operator= (s); -} - -// Compare this array with for inequality. - -template ACE_INLINE bool -ACE_Array::operator!= (const ACE_Array &s) const -{ - return !(*this == s); -} - -// **************************************************************** - - -// **************************************************************** - -template ACE_INLINE void -ACE_DLList::operator= (const ACE_DLList &l) -{ - *(ACE_DLList_Base *) this = l; -} - -template ACE_INLINE int -ACE_DLList::get (T *&item, size_t index) -{ - ACE_DLList_Node *node; - int result = ACE_DLList_Base::get (node, index); - if (result != -1) - item = (T *) node->item_; - return result; -} - -template ACE_INLINE void -ACE_DLList::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_DLList_Base::dump (); -#endif /* ACE_HAS_DUMP */ -} - -template ACE_INLINE int -ACE_DLList::remove (ACE_DLList_Node *n) -{ - int result = ACE_DLList_Base::remove (n); - ACE_DES_FREE (n, - this->allocator_->free, - ACE_DLList_Node); - return result; -} - -template ACE_INLINE -ACE_DLList::ACE_DLList (ACE_Allocator *alloc) - : ACE_DLList_Base (alloc) -{ -} - -template ACE_INLINE -ACE_DLList::ACE_DLList (const ACE_DLList &l) - : ACE_DLList_Base ((ACE_DLList &) l) -{ -} - -template ACE_INLINE -ACE_DLList::~ACE_DLList (void) -{ - while (this->delete_head ()) ; -} - -template ACE_INLINE int -ACE_DLList_Iterator::remove (void) -{ - ACE_DLList_Node *temp = this->ACE_Double_Linked_List_Iterator ::next (); - this->ACE_Double_Linked_List_Iterator ::advance (); - return list_->remove (temp); -} - -template ACE_INLINE -ACE_DLList_Iterator::ACE_DLList_Iterator (ACE_DLList &l) - : ACE_Double_Linked_List_Iterator ((ACE_DLList_Base &)l), - list_ (&l) -{ -} - -template ACE_INLINE void -ACE_DLList_Iterator::reset (ACE_DLList &l) -{ - list_ = &l; - this->ACE_Double_Linked_List_Iterator ::reset ((ACE_DLList_Base &)l); -} - -template ACE_INLINE int -ACE_DLList_Iterator::next (T *&ptr) -{ - ACE_DLList_Node *temp = - ACE_Double_Linked_List_Iterator ::next (); - if (temp) - ptr = (T *) temp->item_; - return temp ? 1 : 0; -} - -template ACE_INLINE T * -ACE_DLList_Iterator::next (void) const -{ - ACE_DLList_Node *temp = ACE_Double_Linked_List_Iterator ::next (); - return (T *) (temp ? temp->item_ : 0); -} - -template ACE_INLINE int -ACE_DLList_Iterator::advance (void) -{ - return this->ACE_Double_Linked_List_Iterator ::advance (); -} - -template ACE_INLINE void -ACE_DLList_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_Double_Linked_List_Iterator ::dump (); -#endif /* ACE_HAS_DUMP */ -} - - -template ACE_INLINE int -ACE_DLList_Reverse_Iterator::remove (void) -{ - ACE_DLList_Node *temp = ACE_Double_Linked_List_Reverse_Iterator ::next (); - this->ACE_Double_Linked_List_Reverse_Iterator ::advance (); - return list_->remove (temp); -} - -template ACE_INLINE -ACE_DLList_Reverse_Iterator::ACE_DLList_Reverse_Iterator (ACE_DLList &l) - : ACE_Double_Linked_List_Reverse_Iterator ((ACE_DLList_Base &)l), - list_ (&l) -{ -} - -template ACE_INLINE void -ACE_DLList_Reverse_Iterator::reset (ACE_DLList &l) -{ - list_ = &l; - this->ACE_Double_Linked_List_Reverse_Iterator ::reset ((ACE_DLList_Base &)l); -} - -template ACE_INLINE int -ACE_DLList_Reverse_Iterator::advance (void) -{ - return ACE_Double_Linked_List_Reverse_Iterator ::advance (); -} - -template ACE_INLINE int -ACE_DLList_Reverse_Iterator::next (T *&ptr) -{ - ACE_DLList_Node *temp = - ACE_Double_Linked_List_Reverse_Iterator ::next (); - if (temp == 0) - return 0; - ptr = (T *) temp->item_; - return 1; -} - -template ACE_INLINE T * -ACE_DLList_Reverse_Iterator::next (void) const -{ - ACE_DLList_Node *temp = ACE_Double_Linked_List_Reverse_Iterator ::next (); - return (T *) (temp ? temp->item_ : 0); -} - - -template ACE_INLINE void -ACE_DLList_Reverse_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_Double_Linked_List_Reverse_Iterator ::dump (); -#endif /* ACE_HAS_DUMP */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Copy_Disabled.cpp b/deps/acelite/ace/Copy_Disabled.cpp deleted file mode 100644 index 59c6ba7af..000000000 --- a/deps/acelite/ace/Copy_Disabled.cpp +++ /dev/null @@ -1,15 +0,0 @@ -/** - * @file Copy_Disabled.cpp - * - * @author Carlos O'Ryan - */ - -#include "ace/Copy_Disabled.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Copy_Disabled::ACE_Copy_Disabled (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Copy_Disabled.h b/deps/acelite/ace/Copy_Disabled.h deleted file mode 100644 index 0617bd874..000000000 --- a/deps/acelite/ace/Copy_Disabled.h +++ /dev/null @@ -1,61 +0,0 @@ -// -*- C++ -*- - -//=========================================================================== -/** - * @file Copy_Disabled.h - * - * @author Carlos O'Ryan - */ -//=========================================================================== - -#ifndef ACE_COPY_DISABLED_H -#define ACE_COPY_DISABLED_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Copy_Disabled - * - * @brief Helper class to disable copy construction and assignment - * - * Classes used to control OS and other resources are not "canonical", - * i.e. they have their copy constructor and assignment operators - * disabled. - * This is often done by making the copy constructor and assignment - * operators private, effectively disallowing copying by clients of - * the class (including derived classes). If the copy constructor and - * assingment operators are left unimplemented then the class itself - * cannot make any copies of its instances, because it would result in - * link errors. - * - * To use this class simply use private inheritance: - * - * class Foo : private ACE_Copy_Disabled - * { - * // code here - * }; - */ -class ACE_Export ACE_Copy_Disabled -{ -public: - /// Default constructor - ACE_Copy_Disabled (void); - -private: - ACE_Copy_Disabled (const ACE_Copy_Disabled &); - ACE_Copy_Disabled &operator= (const ACE_Copy_Disabled &); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#endif /* ACE_COPY_DISABLED_H */ diff --git a/deps/acelite/ace/Countdown_Time.h b/deps/acelite/ace/Countdown_Time.h deleted file mode 100644 index b6966d68f..000000000 --- a/deps/acelite/ace/Countdown_Time.h +++ /dev/null @@ -1,34 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Countdown_Time.h - * - * @author Douglas C. Schmidt - * @author Irfan Pyarali - */ -//============================================================================= - -#ifndef ACE_COUNTDOWN_TIME_H -#define ACE_COUNTDOWN_TIME_H - -#include /**/ "ace/pre.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Countdown_Time_T.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// The following typedef is here for ease of use and backward -// compatibility. -typedef ACE_Countdown_Time_T - ACE_Countdown_Time; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#endif /* ACE_COUNTDOWN_TIME_H */ diff --git a/deps/acelite/ace/Countdown_Time_T.cpp b/deps/acelite/ace/Countdown_Time_T.cpp deleted file mode 100644 index 8a38c4de1..000000000 --- a/deps/acelite/ace/Countdown_Time_T.cpp +++ /dev/null @@ -1,65 +0,0 @@ -#ifndef ACE_COUNTDOWN_TIME_T_CPP -#define ACE_COUNTDOWN_TIME_T_CPP - -#include "ace/Countdown_Time_T.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Countdown_Time_T.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE -ACE_Countdown_Time_T::ACE_Countdown_Time_T (ACE_Time_Value *max_wait_time, - TIME_POLICY const & time_policy) - : time_policy_ (time_policy), - max_wait_time_ (max_wait_time), - max_wait_value_ (ACE_Time_Value::zero), - stopped_ (false) -{ - this->start (); -} - -template ACE_INLINE -ACE_Countdown_Time_T::~ACE_Countdown_Time_T (void) -{ - this->stop (); -} - -template ACE_INLINE void -ACE_Countdown_Time_T::start (void) -{ - if (this->max_wait_time_ != 0) - { - this->max_wait_value_ = *this->max_wait_time_; - this->start_time_ = this->time_policy_ (); - this->stopped_ = false; - } -} - -template ACE_INLINE void -ACE_Countdown_Time_T::stop (void) -{ - if (this->max_wait_time_ != 0 && !this->stopped_) - { - ACE_Time_Value const elapsed_time = - this->time_policy_ () - this->start_time_; - - if (elapsed_time >= ACE_Time_Value::zero && - this->max_wait_value_ > elapsed_time) - { - *this->max_wait_time_ = this->max_wait_value_ - elapsed_time; - } - else - { - // Used all of timeout. - *this->max_wait_time_ = ACE_Time_Value::zero; - // errno = ETIME; - } - this->stopped_ = true; - } -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_COUNTDOWN_TIME_T_CPP */ diff --git a/deps/acelite/ace/Countdown_Time_T.h b/deps/acelite/ace/Countdown_Time_T.h deleted file mode 100644 index 12aab657b..000000000 --- a/deps/acelite/ace/Countdown_Time_T.h +++ /dev/null @@ -1,101 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Countdown_Time_T.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_COUNTDOWN_TIME_T_H -#define ACE_COUNTDOWN_TIME_T_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Time_Value.h" -#include "ace/Time_Policy.h" -#include "ace/Copy_Disabled.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Countdown_Time - * - * @brief Keeps track of the amount of elapsed time. - * - * This class has a side-effect on the @c max_wait_time -- every - * time the stop() method is called the @c max_wait_time is - * updated. - */ -template -class ACE_Countdown_Time_T : private ACE_Copy_Disabled -{ -public: - /// Cache the @a max_wait_time and call @c start(). - ACE_Countdown_Time_T (ACE_Time_Value *max_wait_time, - TIME_POLICY const & time_policy = TIME_POLICY()); - - /// Destructor, makes sure the max_wait_time that got passed as pointer - /// to the constructor is updated with the time elapsed. - ~ACE_Countdown_Time_T (void); - - /// Cache the current time and enter a start state. - void start (void); - - /// Subtract the elapsed time from max_wait_time_ and enter a stopped - /// state. - void stop (void); - - /// Calls stop and then start. max_wait_time_ is modified by the - /// call to stop. - void update (void); - - /// Returns true if we've already been stopped, else false. - bool stopped (void) const; - - /// Allows applications to control how the timer queue gets the time - /// of day. - void set_time_policy(TIME_POLICY const & time_policy); - -private: - /// The policy to return the current time of day - TIME_POLICY time_policy_; - - /// Maximum time we are monitoring - ACE_Time_Value *max_wait_time_; - - /// Copy of the maximum time value, used to avoid nested decrements - ACE_Time_Value max_wait_value_; - - /// Beginning of the start time. - ACE_Time_Value start_time_; - - /// Keeps track of whether we've already been stopped. - bool stopped_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#if defined (__ACE_INLINE__) -#include "ace/Countdown_Time_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Countdown_Time_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Countdown_Time_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - - -#endif /* ACE_COUNTDOWN_TIME_T_H */ diff --git a/deps/acelite/ace/Countdown_Time_T.inl b/deps/acelite/ace/Countdown_Time_T.inl deleted file mode 100644 index 319729d9c..000000000 --- a/deps/acelite/ace/Countdown_Time_T.inl +++ /dev/null @@ -1,23 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE bool -ACE_Countdown_Time_T::stopped (void) const -{ - return stopped_; -} - -template ACE_INLINE void -ACE_Countdown_Time_T::update (void) -{ - this->stop (); - this->start (); -} - -template ACE_INLINE void -ACE_Countdown_Time_T::set_time_policy(TIME_POLICY const & time_policy) -{ - this->time_policy_ = time_policy; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/DEV.cpp b/deps/acelite/ace/DEV.cpp deleted file mode 100644 index 08a7e581f..000000000 --- a/deps/acelite/ace/DEV.cpp +++ /dev/null @@ -1,45 +0,0 @@ -#include "ace/DEV.h" - -#include "ace/OS_NS_unistd.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/DEV.inl" -#endif /* __ACE_INLINE__ */ - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_DEV) - -void -ACE_DEV::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_DEV::dump"); -#endif /* ACE_HAS_DUMP */ -} - -// This is the do-nothing constructor. - -ACE_DEV::ACE_DEV (void) -{ - ACE_TRACE ("ACE_DEV::ACE_DEV"); -} - -// Close the device - -int -ACE_DEV::close (void) -{ - ACE_TRACE ("ACE_DEV::close"); - int result = ACE_OS::close (this->get_handle ()); - this->set_handle (ACE_INVALID_HANDLE); - return result; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/DEV.h b/deps/acelite/ace/DEV.h deleted file mode 100644 index c74c23429..000000000 --- a/deps/acelite/ace/DEV.h +++ /dev/null @@ -1,63 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file DEV.h - * - * @author Gerhard Lenzer - */ -//============================================================================= - - -#ifndef ACE_DEV_H -#define ACE_DEV_H -#include /**/ "ace/pre.h" - -#include "ace/IO_SAP.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/DEV_Addr.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_DEV - * - * @brief Defines the member functions for the base class of the - * ACE_DEV abstraction. - */ -class ACE_Export ACE_DEV : public ACE_IO_SAP -{ -public: - /// Close down the DEVICE - int close (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - /** - * Disable signal @a signum - * This is here to prevent Win32 from - * disabling SPIPE using socket calls - */ - int disable (int signum) const ; - -protected: - /// Ensure that this class is an abstract base class - ACE_DEV (void); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/DEV.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_DEV_H */ diff --git a/deps/acelite/ace/DEV.inl b/deps/acelite/ace/DEV.inl deleted file mode 100644 index ee0bb7838..000000000 --- a/deps/acelite/ace/DEV.inl +++ /dev/null @@ -1,15 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE int -ACE_DEV::disable (int signum) const -{ -#if defined (ACE_WIN32) - ACE_UNUSED_ARG (signum) ; - return 0 ; -#else /* ACE_WIN32 */ - return ACE_IO_SAP::disable (signum) ; -#endif /* ACE_WIN32 */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/DEV_Addr.cpp b/deps/acelite/ace/DEV_Addr.cpp deleted file mode 100644 index c5c2cc3bc..000000000 --- a/deps/acelite/ace/DEV_Addr.cpp +++ /dev/null @@ -1,105 +0,0 @@ -#include "ace/DEV_Addr.h" -#if !defined (__ACE_INLINE__) -#include "ace/DEV_Addr.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Log_Category.h" -#include "ace/OS_NS_string.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_DEV_Addr) - -// Transform the current address into string format. - -int -ACE_DEV_Addr::addr_to_string (ACE_TCHAR *s, size_t len) const -{ - ACE_TRACE ("ACE_DEV_Addr::addr_to_string"); - - ACE_OS::strsncpy (s, this->devname_, len); - return 0; -} - -// Return a pointer to the address. - -void * -ACE_DEV_Addr::get_addr (void) const -{ - ACE_TRACE ("ACE_DEV_Addr::get_addr"); - - return (void *) &this->devname_; -} - -void -ACE_DEV_Addr::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_DEV_Addr::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("devname_ = %s"), this->devname_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -// Do nothing constructor. - -ACE_DEV_Addr::ACE_DEV_Addr (void) - : ACE_Addr (AF_DEV, sizeof this->devname_) -{ - ACE_TRACE ("ACE_DEV_Addr::ACE_DEV_Addr"); - - (void) ACE_OS::memset ((void *) &this->devname_, - 0, sizeof this->devname_); -} - -int -ACE_DEV_Addr::set (const ACE_DEV_Addr &sa) -{ - this->base_set (sa.get_type (), sa.get_size ()); - - if (sa.get_type () == AF_ANY) - (void) ACE_OS::memset ((void *) &this->devname_, - 0, - sizeof this->devname_); - else - (void) ACE_OS::strsncpy (this->devname_, - sa.devname_, - ACE_DEV_Addr::DEVNAME_LENGTH); - return 0; -} - -// Copy constructor. - -ACE_DEV_Addr::ACE_DEV_Addr (const ACE_DEV_Addr &sa) - : ACE_Addr (AF_DEV, sizeof this->devname_) -{ - ACE_TRACE ("ACE_DEV_Addr::ACE_DEV_Addr"); - - this->set (sa); -} - -ACE_DEV_Addr::ACE_DEV_Addr (const ACE_TCHAR *devname) - : ACE_Addr (AF_DEV, sizeof this->devname_) -{ - ACE_TRACE ("ACE_DEV_Addr::ACE_DEV_Addr"); - - this->set (devname); -} - -ACE_DEV_Addr & -ACE_DEV_Addr::operator= (const ACE_DEV_Addr &sa) -{ - ACE_TRACE ("ACE_DEV_Addr::operator="); - - if (this != &sa) - this->set (sa); - - return *this; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/DEV_Addr.h b/deps/acelite/ace/DEV_Addr.h deleted file mode 100644 index ed17c0bfc..000000000 --- a/deps/acelite/ace/DEV_Addr.h +++ /dev/null @@ -1,87 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file DEV_Addr.h - * - * @author Gerhard Lenzer and Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_DEV_ADDR_H -#define ACE_DEV_ADDR_H - -#include /**/ "ace/pre.h" - -#include "ace/Addr.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/os_include/os_dirent.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_DEV_Addr - * - * @brief Defines device address family address format. - */ -class ACE_Export ACE_DEV_Addr : public ACE_Addr -{ -public: - /// Default constructor. - ACE_DEV_Addr (void); - - /// Copy constructor. - ACE_DEV_Addr (const ACE_DEV_Addr &sa); - - /// Acts like a copy constructor. - int set (const ACE_DEV_Addr &sa); - - /// Create a ACE_DEV_Addr from a device name. - explicit ACE_DEV_Addr (const ACE_TCHAR *devname); - - /// Create a ACE_Addr from a ACE_DEV pathname. - void set (const ACE_TCHAR *devname); - - /// Assignment operator. - ACE_DEV_Addr &operator= (const ACE_DEV_Addr &); - - /// Return a pointer to the address. - virtual void *get_addr (void) const; - - /// Transform the current address into string format. - virtual int addr_to_string (ACE_TCHAR *addr, size_t) const; - - /// Compare two addresses for equality. - bool operator == (const ACE_DEV_Addr &SAP) const; - - /// Compare two addresses for inequality. - bool operator != (const ACE_DEV_Addr &SAP) const; - - /// Return the path name used for the rendezvous point. - const ACE_TCHAR *get_path_name (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - enum { DEVNAME_LENGTH = MAXPATHLEN + 1 }; - /// Name of the device. - ACE_TCHAR devname_[DEVNAME_LENGTH]; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/DEV_Addr.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* ACE_DEV_ADDR_H */ diff --git a/deps/acelite/ace/DEV_Addr.inl b/deps/acelite/ace/DEV_Addr.inl deleted file mode 100644 index 3025745f2..000000000 --- a/deps/acelite/ace/DEV_Addr.inl +++ /dev/null @@ -1,48 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_string.h" -#include "ace/Global_Macros.h" -#include "ace/os_include/sys/os_socket.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE void -ACE_DEV_Addr::set (const ACE_TCHAR *devname) -{ - ACE_TRACE ("ACE_DEV_Addr::set"); - - this->ACE_Addr::base_set - (AF_DEV, static_cast (ACE_OS::strlen (devname))); - ACE_OS::strsncpy (this->devname_, devname, ACE_DEV_Addr::DEVNAME_LENGTH); -} - -// Compare two addresses for equality. - -ACE_INLINE bool -ACE_DEV_Addr::operator == (const ACE_DEV_Addr &sap) const -{ - ACE_TRACE ("ACE_DEV_Addr::operator =="); - - return ACE_OS::strcmp (this->devname_, sap.devname_) == 0; -} - -// Compare two addresses for inequality. - -ACE_INLINE bool -ACE_DEV_Addr::operator != (const ACE_DEV_Addr &sap) const -{ - ACE_TRACE ("ACE_DEV_Addr::operator !="); - - return !((*this) == sap); // This is lazy, of course... ;-). -} - -// Return the path name used for the rendezvous point. - -ACE_INLINE const ACE_TCHAR * -ACE_DEV_Addr::get_path_name (void) const -{ - ACE_TRACE ("ACE_DEV_Addr::get_path_name"); - - return this->devname_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/DEV_Connector.cpp b/deps/acelite/ace/DEV_Connector.cpp deleted file mode 100644 index 159e5ecee..000000000 --- a/deps/acelite/ace/DEV_Connector.cpp +++ /dev/null @@ -1,48 +0,0 @@ -#include "ace/DEV_Connector.h" - -#include "ace/Handle_Ops.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/DEV_Connector.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_DEV_Connector) - -void -ACE_DEV_Connector::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_DEV_Connector::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_DEV_Connector::ACE_DEV_Connector (void) -{ - ACE_TRACE ("ACE_DEV_Connector::ACE_DEV_Connector"); -} - -int -ACE_DEV_Connector::connect (ACE_DEV_IO &new_io, - const ACE_DEV_Addr &remote_sap, - ACE_Time_Value *timeout, - const ACE_Addr &, - int, - int flags, - int perms) -{ - ACE_TRACE ("ACE_DEV_Connector::connect"); - - ACE_HANDLE handle = ACE::handle_timed_open (timeout, - remote_sap.get_path_name (), - flags, perms); - new_io.set_handle (handle); - new_io.addr_ = remote_sap; // class copy. - return handle == ACE_INVALID_HANDLE ? -1 : 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/DEV_Connector.h b/deps/acelite/ace/DEV_Connector.h deleted file mode 100644 index 5916ba8f1..000000000 --- a/deps/acelite/ace/DEV_Connector.h +++ /dev/null @@ -1,107 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file DEV_Connector.h - * - * @author Gerhard Lenzer and Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_DEV_CONNECTOR_H -#define ACE_DEV_CONNECTOR_H -#include /**/ "ace/pre.h" - -#include "ace/DEV_IO.h" -#include "ace/Log_Category.h" -#include "ace/os_include/os_fcntl.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_DEV_Connector - * - * @brief Defines an active connection factory for the ACE_DEV wrappers. - */ -class ACE_Export ACE_DEV_Connector -{ -public: - /// Default constructor. - ACE_DEV_Connector (void); - - /** - * Actively connect and produce a @a new_io if things go well. - * The @a remote_sap is the address that we are trying to connect - * with. The @a timeout is the amount of time to wait to connect. - * If it's 0 then we block indefinitely. If *timeout == {0, 0} then - * the connection is done using non-blocking mode. In this case, if - * the connection can't be made immediately the value of -1 is - * returned with @c errno == EWOULDBLOCK. If *timeout > {0, 0} then - * this is the maximum amount of time to wait before timing out. If the - * time expires before the connection is made @c errno == ETIME. The - * @a local_sap is the value of local address to bind to. If it's - * the default value of ACE_Addr::sap_any then the user is letting - * the OS do the binding. If @a reuse_addr == 1 then the - * is reused, even if it hasn't been cleanedup yet. - * The @a flags and @a perms arguments are passed down to the - * method. - */ - ACE_DEV_Connector (ACE_DEV_IO &new_io, - const ACE_DEV_Addr &remote_sap, - ACE_Time_Value *timeout = 0, - const ACE_Addr &local_sap = ACE_Addr::sap_any, - int reuse_addr = 0, - int flags = O_RDWR, - int perms = 0); - - /** - * Actively connect and produce a @a new_io if things go well. - * The @a remote_sap is the address that we are trying to connect - * with. The @a timeout is the amount of time to wait to connect. - * If it's 0 then we block indefinitely. If *timeout == {0, 0} then - * the connection is done using non-blocking mode. In this case, if - * the connection can't be made immediately the value of -1 is - * returned with @c errno == EWOULDBLOCK. If *timeout > {0, 0} then - * this is the maximum amount of time to wait before timing out. If the - * time expires before the connection is made @c errno == ETIME. The - * @a local_sap is the value of local address to bind to. If it's - * the default value of ACE_Addr::sap_any then the user is letting - * the OS do the binding. If @a reuse_addr == 1 then the - * is reused, even if it hasn't been cleanedup yet. - * The @a flags and @a perms arguments are passed down to the - * method. - */ - int connect (ACE_DEV_IO &new_io, - const ACE_DEV_Addr &remote_sap, - ACE_Time_Value *timeout = 0, - const ACE_Addr &local_sap = ACE_Addr::sap_any, - int reuse_addr = 0, - int flags = O_RDWR, - int perms = 0); - - /// Resets any event associations on this handle - bool reset_new_handle (ACE_HANDLE handle); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - // = Meta-type info - typedef ACE_DEV_Addr PEER_ADDR; - typedef ACE_DEV_IO PEER_STREAM; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/DEV_Connector.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_DEV_CONNECTOR_H */ diff --git a/deps/acelite/ace/DEV_Connector.inl b/deps/acelite/ace/DEV_Connector.inl deleted file mode 100644 index b92b4d2a5..000000000 --- a/deps/acelite/ace/DEV_Connector.inl +++ /dev/null @@ -1,30 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Creates a Local ACE_DEV. - -ACE_INLINE -ACE_DEV_Connector::ACE_DEV_Connector (ACE_DEV_IO &new_io, - const ACE_DEV_Addr &remote_sap, - ACE_Time_Value *timeout, - const ACE_Addr &local_sap, - int reuse_addr, - int flags, - int perms) -{ - ACE_TRACE ("ACE_DEV_Connector::ACE_DEV_Connector"); - if (this->connect (new_io, remote_sap, timeout, local_sap, - reuse_addr, flags, perms) == ACE_IO_SAP::INVALID_HANDLE - && timeout != 0 && !(errno == EWOULDBLOCK || errno == ETIME)) - ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("address %s, %p\n"), - remote_sap.get_path_name (), ACE_TEXT ("ACE_DEV_IO"))); -} - -ACE_INLINE bool -ACE_DEV_Connector::reset_new_handle (ACE_HANDLE) -{ - // Nothing to do here since the handle is not a socket - return false; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/DEV_IO.cpp b/deps/acelite/ace/DEV_IO.cpp deleted file mode 100644 index f1dcda429..000000000 --- a/deps/acelite/ace/DEV_IO.cpp +++ /dev/null @@ -1,164 +0,0 @@ -#include "ace/DEV_IO.h" -#include "ace/Log_Category.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/DEV_IO.inl" -#endif /* __ACE_INLINE__ */ - - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_DEV_IO) - -// Return the local endpoint address. - -int -ACE_DEV_IO::get_local_addr (ACE_DEV_Addr &addr) const -{ - ACE_TRACE ("ACE_DEV_IO::get_local_addr"); - - addr = this->addr_; - return 0; -} - -// Return the address of the remotely connected peer (if there is -// one). - -int -ACE_DEV_IO::get_remote_addr (ACE_DEV_Addr &addr) const -{ - ACE_TRACE ("ACE_DEV_IO::get_remote_addr"); - addr = this->addr_; - return 0; -} - -void -ACE_DEV_IO::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_DEV_IO::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->addr_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -// Simple-minded do nothing constructor. - -ACE_DEV_IO::ACE_DEV_IO (void) -{ - ACE_TRACE ("ACE_DEV_IO::ACE_DEV_IO"); -} - -// Send N char *ptrs and int lengths. Note that the char *'s precede -// the ints (basically, an varargs version of writev). The count N is -// the *total* number of trailing arguments, *not* a couple of the -// number of tuple pairs! - -ssize_t -ACE_DEV_IO::send (size_t n, ...) const -{ - ACE_TRACE ("ACE_DEV_IO::send"); -#ifdef ACE_LACKS_VA_FUNCTIONS - ACE_UNUSED_ARG (n); - ACE_NOTSUP_RETURN (-1); -#else - va_list argp; - int total_tuples = static_cast (n / 2); - iovec *iovp; -#if defined (ACE_HAS_ALLOCA) - iovp = (iovec *) alloca (total_tuples * sizeof (iovec)); -#else -# ifdef ACE_HAS_ALLOC_HOOKS - ACE_ALLOCATOR_RETURN (iovp, (iovec *) - ACE_Allocator::instance ()->malloc (total_tuples * - sizeof (iovec)), - -1); -# else - ACE_NEW_RETURN (iovp, - iovec[total_tuples], - -1); -# endif /* ACE_HAS_ALLOC_HOOKS */ -#endif /* !defined (ACE_HAS_ALLOCA) */ - - va_start (argp, n); - - for (int i = 0; i < total_tuples; i++) - { - iovp[i].iov_base = va_arg (argp, char *); - iovp[i].iov_len = va_arg (argp, int); - } - - ssize_t result = ACE_OS::writev (this->get_handle (), iovp, total_tuples); -#if !defined (ACE_HAS_ALLOCA) -# ifdef ACE_HAS_ALLOC_HOOKS - ACE_Allocator::instance ()->free (iovp); -# else - delete [] iovp; -# endif /* ACE_HAS_ALLOC_HOOKS */ -#endif /* !defined (ACE_HAS_ALLOCA) */ - va_end (argp); - return result; -#endif // ACE_LACKS_VA_FUNCTIONS -} - -// This is basically an interface to ACE_OS::readv, that doesn't use the -// struct iovec explicitly. The ... can be passed as an arbitrary -// number of (char *ptr, int len) tuples. However, the count N is the -// *total* number of trailing arguments, *not* a couple of the number -// of tuple pairs! - -ssize_t -ACE_DEV_IO::recv (size_t n, ...) const -{ - ACE_TRACE ("ACE_DEV_IO::recv"); -#ifdef ACE_LACKS_VA_FUNCTIONS - ACE_UNUSED_ARG (n); - ACE_NOTSUP_RETURN (-1); -#else - va_list argp; - int total_tuples = static_cast (n / 2); - iovec *iovp; -#if defined (ACE_HAS_ALLOCA) - iovp = (iovec *) alloca (total_tuples * sizeof (iovec)); -#else -# ifdef ACE_HAS_ALLOC_HOOKS - ACE_ALLOCATOR_RETURN (iovp, (iovec *) - ACE_Allocator::instance ()->malloc (total_tuples * - sizeof (iovec)), - -1); -# else - ACE_NEW_RETURN (iovp, - iovec[total_tuples], - -1); -# endif /* ACE_HAS_ALLOC_HOOKS */ -#endif /* !defined (ACE_HAS_ALLOCA) */ - - va_start (argp, n); - - for (int i = 0; i < total_tuples; i++) - { - iovp[i].iov_base = va_arg (argp, char *); - iovp[i].iov_len = va_arg (argp, int); - } - - ssize_t result = ACE_OS::readv (this->get_handle (), iovp, total_tuples); -#if !defined (ACE_HAS_ALLOCA) -# ifdef ACE_HAS_ALLOC_HOOKS - ACE_Allocator::instance ()->free (iovp); -# else - delete [] iovp; -# endif /* ACE_HAS_ALLOC_HOOKS */ -#endif /* !defined (ACE_HAS_ALLOCA) */ - va_end (argp); - return result; -#endif // ACE_LACKS_VA_FUNCTIONS -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/DEV_IO.h b/deps/acelite/ace/DEV_IO.h deleted file mode 100644 index 9a97c011f..000000000 --- a/deps/acelite/ace/DEV_IO.h +++ /dev/null @@ -1,183 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file DEV_IO.h - * - * @author Gerhard Lenzer - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_DEV_IO_H -#define ACE_DEV_IO_H -#include /**/ "ace/pre.h" - -#include "ace/DEV.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_STREAM_PIPES) -# include "ace/OS_NS_stropts.h" -#endif /* ACE_HAS_STREAM_PIPES */ - -#include "ace/os_include/os_stdio.h" -#include "ace/os_include/sys/os_uio.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Time_Value; - -/** - * @class ACE_DEV_IO - * - * @brief Read/Write operations on Devices. - */ -class ACE_Export ACE_DEV_IO : public ACE_DEV -{ -public: - friend class ACE_DEV_Connector; - - /// Default constructor. - ACE_DEV_IO (void); - - // = Various send operations. - /// send upto @a n bytes in @a buf. - ssize_t send (const void *buf, size_t n) const; - - /// Recv upto @a n bytes in @a buf. - ssize_t recv (void *buf, size_t n) const; - - /// Send n bytes, keep trying until n are sent. - ssize_t send_n (const void *buf, - size_t n) const; - - /** - * @name I/O operations - * - * Notes on common parameters: - * - * @a buf is the buffer to write from or receive into. - * - * @a len is the number of bytes to transfer. - * - * The @a timeout parameter in the following methods indicates how - * long to blocking trying to transfer data. If @a timeout == 0, - * then the call behaves as a normal send/recv call, i.e., for - * blocking sockets, the call will block until action is possible; - * for non-blocking sockets, EWOULDBLOCK will be returned if no - * action is immediately possible. - * - * If @a timeout != 0, the call will wait until the relative time - * specified in *@a timeout elapses. - * - * The "_n()" I/O methods keep looping until all the data has been - * transferred. These methods also work for sockets in non-blocking - * mode i.e., they keep looping on EWOULDBLOCK. @a timeout is used - * to make sure we keep making progress, i.e., the same timeout - * value is used for every I/O operation in the loop and the timeout - * is not counted down. - * - * The return values for the "*_n()" methods match the return values - * from the non "_n()" methods and are specified as follows: - * - * - On complete transfer, the number of bytes transferred is returned. - * - On timeout, -1 is returned, errno == ETIME. - * - On error, -1 is returned, errno is set to appropriate error. - * - On EOF, 0 is returned, errno is irrelevant. - * - * On partial transfers, i.e., if any data is transferred before - * timeout/error/EOF, @a bytes_transferred will contain the number of - * bytes transferred. - */ - ssize_t recv_n (void *buf, - size_t n, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0) const; - -#if defined (ACE_HAS_STREAM_PIPES) - /// Recv bytes via STREAM pipes using "band" mode. - ssize_t recv (ACE_Str_Buf *cntl, - ACE_Str_Buf *data, - int *band, - int *flags) const; - - /// Send bytes via STREAM pipes using "band" mode. - ssize_t send (const ACE_Str_Buf *cntl, - const ACE_Str_Buf *data, - int band, - int flags) const; - - /// Recv @a cntl and @a data via STREAM pipes. - ssize_t recv (ACE_Str_Buf *cntl, - ACE_Str_Buf *data, - int *flags) const; - - /// Send @a cntl and @a data via STREAM pipes. - ssize_t send (const ACE_Str_Buf *cntl, - const ACE_Str_Buf *data, - int flags = 0) const; -#endif /* ACE_HAS_STREAM_PIPES */ - - /// Send iovecs via <::writev>. - ssize_t send (const iovec iov[], size_t n) const; - - /// Recv iovecs via <::readv>. - ssize_t recv (iovec iov[], size_t n) const; - - /** - * Send N char *ptrs and int lengths. Note that the char *'s - * precede the ints (basically, an varargs version of writev). The - * count N is the *total* number of trailing arguments, *not* a - * couple of the number of tuple pairs! - */ - ssize_t send (size_t n, ...) const; - - /** - * This is an interface to ::readv, that doesn't use the struct - * iovec explicitly. The ... can be passed as an arbitrary number - * of (char *ptr, int len) tuples. However, the count N is the - * *total* number of trailing arguments, *not* a couple of the - * number of tuple pairs! - */ - ssize_t recv (size_t n, ...) const; - - /// Send @a n bytes via Win32 WriteFile using overlapped I/O. - ssize_t send (const void *buf, size_t n, ACE_OVERLAPPED *overlapped) const; - - /// Recv @a n bytes via Win32 ReadFile using overlapped I/O. - ssize_t recv (void *buf, size_t n, ACE_OVERLAPPED *overlapped) const; - - /// Dump the state of an object. - void dump (void) const; - - // = The following two methods are no-ops to keep the - // ACE_Connector happy. - /// Return the local endpoint address. - int get_local_addr (ACE_DEV_Addr &) const; - - /// Return the address of the remotely connected peer (if there is - /// one). - int get_remote_addr (ACE_DEV_Addr &) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - // = Meta-type info - typedef ACE_DEV_Addr PEER_ADDR; - -private: - /// Address of device we are connected to. - ACE_DEV_Addr addr_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/DEV_IO.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_DEV_IO_H */ diff --git a/deps/acelite/ace/DEV_IO.inl b/deps/acelite/ace/DEV_IO.inl deleted file mode 100644 index 45e4a0970..000000000 --- a/deps/acelite/ace/DEV_IO.inl +++ /dev/null @@ -1,123 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_sys_uio.h" -#include "ace/OS_NS_unistd.h" -#include "ace/OS_Memory.h" - -#include "ace/ACE.h" - -// Send exactly N bytes from BUF to this device. Keeping trying until -// this many bytes are sent. - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE ssize_t -ACE_DEV_IO::send_n (const void *buf, size_t n) const -{ - ACE_TRACE ("ACE_DEV_IO::send_n"); - return ACE::write_n (this->get_handle (), buf, n); -} - -// Receive exactly N bytes from this file into BUF. Keep trying until -// this many bytes are received. - -ACE_INLINE ssize_t -ACE_DEV_IO::recv_n (void *buf, - size_t n, - const ACE_Time_Value *timeout, - size_t *bytes_transferred) const -{ - ACE_TRACE ("ACE_DEV_IO::recv_n"); -#if defined (ACE_WIN32) - ACE_UNUSED_ARG (timeout); - - return ACE::read_n (this->get_handle (), - buf, - n, - bytes_transferred); -#else - return ACE::recv_n (this->get_handle (), - buf, - n, - timeout, - bytes_transferred); -#endif /*ACE_WIN32*/ -} - -ACE_INLINE ssize_t -ACE_DEV_IO::send (const void *buf, size_t n) const -{ - ACE_TRACE ("ACE_DEV_IO::send"); - return ACE_OS::write (this->get_handle (), (const char *) buf, n); -} - -ACE_INLINE ssize_t -ACE_DEV_IO::recv (void *buf, size_t n) const -{ - ACE_TRACE ("ACE_DEV_IO::recv"); - return ACE_OS::read (this->get_handle (), (char *) buf, n); -} - -ACE_INLINE ssize_t -ACE_DEV_IO::send (const iovec iov[], size_t n) const -{ - ACE_TRACE ("ACE_DEV_IO::send"); - return ACE_OS::writev (this->get_handle (), iov, static_cast (n)); -} - -ACE_INLINE ssize_t -ACE_DEV_IO::recv (iovec iov[], size_t n) const -{ - ACE_TRACE ("ACE_DEV_IO::recv"); - return ACE_OS::readv (this->get_handle (), iov, static_cast (n)); -} - -ACE_INLINE ssize_t -ACE_DEV_IO::send (const void *buf, size_t n, - ACE_OVERLAPPED *overlapped) const -{ - ACE_TRACE ("ACE_DEV_IO::send"); - return ACE_OS::write (this->get_handle (), - (const char *) buf, n, - overlapped); -} - -ACE_INLINE ssize_t -ACE_DEV_IO::recv (void *buf, size_t n, - ACE_OVERLAPPED *overlapped) const -{ - ACE_TRACE ("ACE_DEV_IO::recv"); - return ACE_OS::read (this->get_handle (), (char *) buf, n, - overlapped); -} - -#if defined (ACE_HAS_STREAM_PIPES) -ACE_INLINE ssize_t -ACE_DEV_IO::recv (ACE_Str_Buf *cntl, ACE_Str_Buf *data, int *band, int *flags) const -{ - ACE_TRACE ("ACE_DEV_IO::recv"); - return ACE_OS::getpmsg (this->get_handle (), (strbuf *) cntl, (strbuf *) data, band, flags); -} - -ACE_INLINE ssize_t -ACE_DEV_IO::send (const ACE_Str_Buf *cntl, const ACE_Str_Buf *data, int band, int flags) const -{ - ACE_TRACE ("ACE_DEV_IO::send"); - return ACE_OS::putpmsg (this->get_handle (), (strbuf *) cntl, (strbuf *) data, band, flags); -} - -ACE_INLINE ssize_t -ACE_DEV_IO::recv (ACE_Str_Buf *cntl, ACE_Str_Buf *data, int *flags) const -{ - ACE_TRACE ("ACE_DEV_IO::recv"); - return ACE_OS::getmsg (this->get_handle (), (strbuf *) cntl, (strbuf *) data, flags); -} - -ACE_INLINE ssize_t -ACE_DEV_IO::send (const ACE_Str_Buf *cntl, const ACE_Str_Buf *data, int flags) const -{ - ACE_TRACE ("ACE_DEV_IO::send"); - return ACE_OS::putmsg (this->get_handle (), (strbuf *) cntl, (strbuf *) data, flags); -} -#endif /* ACE_HAS_STREAM_PIPES */ - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/DLL.cpp b/deps/acelite/ace/DLL.cpp deleted file mode 100644 index 998a52a88..000000000 --- a/deps/acelite/ace/DLL.cpp +++ /dev/null @@ -1,287 +0,0 @@ -#include "ace/DLL.h" - -#include "ace/Log_Category.h" -#include "ace/ACE.h" -#include "ace/DLL_Manager.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_NS_dlfcn.h" -#include "ace/OS_NS_Thread.h" - -#include - - - - ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Default constructor. Also, by default, the object will be closed -// before it is destroyed. - -ACE_DLL::ACE_DLL (bool close_handle_on_destruction) - : open_mode_ (0), - dll_name_ (0), - close_handle_on_destruction_ (close_handle_on_destruction), - dll_handle_ (0), - error_ (0) -{ - ACE_TRACE ("ACE_DLL::ACE_DLL (int)"); -} - -ACE_DLL::ACE_DLL (const ACE_DLL &rhs) - : open_mode_ (0), - dll_name_ (0), - close_handle_on_destruction_ (false), - dll_handle_ (0), - error_ (0) -{ - ACE_TRACE ("ACE_DLL::ACE_DLL (const ACE_DLL &)"); - - if (rhs.dll_name_ - // This will automatically up the refcount. - && this->open (rhs.dll_name_, - rhs.open_mode_, - rhs.close_handle_on_destruction_) != 0 - && ACE::debug ()) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE_DLL::copy_ctor: error: %s\n"), - this->error ())); -} - -// Assignment operator - -ACE_DLL & -ACE_DLL::operator= (const ACE_DLL &rhs) -{ - ACE_TRACE ("ACE_DLL::operator= (const ACE_DLL &)"); - - ACE_DLL tmp (rhs); - - std::swap (this->open_mode_, tmp.open_mode_); - std::swap (this->dll_name_, tmp.dll_name_); - std::swap (this->close_handle_on_destruction_, - tmp.close_handle_on_destruction_); - std::swap (this->dll_handle_, tmp.dll_handle_); - std::swap (this->error_, tmp.error_); - - return *this; -} - - -// If the library name and the opening mode are specified than on -// object creation the library is implicitly opened. - -ACE_DLL::ACE_DLL (const ACE_TCHAR *dll_name, - int open_mode, - bool close_handle_on_destruction) - : open_mode_ (open_mode), - dll_name_ (0), - close_handle_on_destruction_ (close_handle_on_destruction), - dll_handle_ (0), - error_ (0) -{ - ACE_TRACE ("ACE_DLL::ACE_DLL"); - - if (this->open (dll_name, this->open_mode_, close_handle_on_destruction) != 0 - && ACE::debug ()) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE_DLL::open: error calling open: %s\n"), - this->error ())); -} - -// The library is closed before the class gets destroyed depending on -// the close_handle_on_destruction value specified which is stored in -// close_handle_on_destruction_. - -ACE_DLL::~ACE_DLL (void) -{ - ACE_TRACE ("ACE_DLL::~ACE_DLL"); - - this->close (); - - // Normally delete()d in ACE_DLL::close(). However, that may not - // occur if full ACE_DLL initialization is interrupted due to errors - // (e.g. attempting to open a DSO/DLL that does not exist). Make - // sure this->dll_name_ is deallocated. -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (this->dll_name_); -#else - delete [] this->dll_name_; -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -// This method opens the library based on the mode specified using the -// ACE_SHLIB_HANDLE which is obtained on making the ACE_OS::dlopen call. -// The default mode is: -// RTLD_LAZY Only references to data symbols are relocate when the -// object is first loaded. -// The other modes include: -// RTLD_NOW All necessary relocations are performed when the -// object is first loaded. -// RTLD_GLOBAL The object symbols are made available for the -// relocation processing of any other object. - -int -ACE_DLL::open (const ACE_TCHAR *dll_filename, - int open_mode, - bool close_handle_on_destruction) -{ - ACE_TRACE ("ACE_DLL::open"); - - return open_i (dll_filename, open_mode, close_handle_on_destruction); -} - -int -ACE_DLL::open_i (const ACE_TCHAR *dll_filename, - int open_mode, - bool close_handle_on_destruction, - ACE_SHLIB_HANDLE handle) -{ - ACE_TRACE ("ACE_DLL::open_i"); - - this->error_ = 0; - this->errmsg_.clear (true); - - if (!dll_filename) - { - if (ACE::debug ()) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE_DLL::open_i: dll_name is %s\n"), - this->dll_name_ == 0 ? ACE_TEXT ("(null)") - : this->dll_name_)); - return -1; - } - - if (this->dll_handle_) - { - // If we have a good handle and its the same name, just return. - if (ACE_OS::strcmp (this->dll_name_, dll_filename) == 0) - return 0; - else - this->close (); - } - - if (!this->dll_name_) - this->dll_name_ = ACE::strnew (dll_filename); - - this->open_mode_ = open_mode; - this->close_handle_on_destruction_ = close_handle_on_destruction; - - ACE_DLL_Handle::ERROR_STACK errors; - this->dll_handle_ = ACE_DLL_Manager::instance()->open_dll (this->dll_name_, - this->open_mode_, - handle, - &errors); - - if (!this->dll_handle_) - { - ACE_TString errtmp; - while (!errors.is_empty ()) - { - errors.pop (errtmp); - if (this->errmsg_.length () > 0) - this->errmsg_ += ACE_TEXT ("\n"); - this->errmsg_ += errtmp; - } - this->error_ = 1; - } - - return this->error_ ? -1 : 0; -} - -// The symbol refernce of the name specified is obtained. - -void * -ACE_DLL::symbol (const ACE_TCHAR *sym_name, int ignore_errors) -{ - ACE_TRACE ("ACE_DLL::symbol"); - - this->error_ = 0; - this->errmsg_.clear (true); - - void *sym = 0; - if (this->dll_handle_) - sym = this->dll_handle_->symbol (sym_name, ignore_errors, this->errmsg_); - - if (!sym) - this->error_ = 1; - - return sym; -} - -// The library is closed using the ACE_SHLIB_HANDLE object, i.e., the -// shared object is now disassociated form the current process. - -int -ACE_DLL::close (void) -{ - ACE_TRACE ("ACE_DLL::close"); - - int retval = 0; - - if (this->dll_handle_ - && this->close_handle_on_destruction_ - && this->dll_name_ - && (retval = ACE_DLL_Manager::instance ()->close_dll (this->dll_name_)) != 0) - this->error_ = 1; - - // Even if close_dll() failed, go ahead and cleanup. - this->dll_handle_ = 0; -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (this->dll_name_); -#else - delete [] this->dll_name_; -#endif /* ACE_HAS_ALLOC_HOOKS */ - this->dll_name_ = 0; - this->close_handle_on_destruction_ = false; - - return retval; -} - -// This method is used return the last error of a library operation. - -ACE_TCHAR * -ACE_DLL::error (void) const -{ - ACE_TRACE ("ACE_DLL::error"); - if (this->error_) - { - return const_cast (this->errmsg_.c_str ()); - } - - return 0; -} - -// Return the handle to the user either temporarily or forever, thus -// orphaning it. If 0 means the user wants the handle forever and if 1 -// means the user temporarily wants to take the handle. - -ACE_SHLIB_HANDLE -ACE_DLL::get_handle (bool become_owner) const -{ - ACE_TRACE ("ACE_DLL::get_handle"); - - ACE_SHLIB_HANDLE handle = ACE_SHLIB_INVALID_HANDLE; - - if (this->dll_handle_) - handle = this->dll_handle_->get_handle (become_owner); - - return handle; -} - -// Set the handle for the DLL. By default, the object will be closed -// before it is destroyed. - -int -ACE_DLL::set_handle (ACE_SHLIB_HANDLE handle, - bool close_handle_on_destruction) -{ - ACE_TRACE ("ACE_DLL::set_handle"); - - // Create a unique name. Note that this name is only guaranteed - // to be unique for the life of this object. - ACE_TCHAR temp[ACE_UNIQUE_NAME_LEN]; - ACE_OS::unique_name (this, temp, ACE_UNIQUE_NAME_LEN); - - return this->open_i (temp, 1, close_handle_on_destruction, handle); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/DLL.h b/deps/acelite/ace/DLL.h deleted file mode 100644 index c64696485..000000000 --- a/deps/acelite/ace/DLL.h +++ /dev/null @@ -1,205 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file DLL.h - * - * @author Kirthika Parameswaran - */ -//============================================================================= - -#ifndef ACE_DLL_H -#define ACE_DLL_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Global_Macros.h" -#include "ace/os_include/os_dlfcn.h" -#include "ace/SString.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_DLL_Handle; - -/** - * @class ACE_DLL - * - * @brief Provides an abstract interface for handling various DLL - * operations. - * - * This class is a wrapper over the various methods for utilizing - * a dynamically linked library (DLL), which is called a shared - * library on some platforms. Operations @c open(), @c close(), and - * @c symbol() have been implemented to help opening/closing and - * extracting symbol information from a DLL, respectively. - */ -class ACE_Export ACE_DLL -{ -public: - /** - * Default constructor. By default, the close() operation on the - * object will be invoked before it is destroyed. - * @param close_handle_on_destruction Indicates whether or not the - * close() method will be called to close an open DLL when this - * object is destroyed. By default, close() will be called. - * Set this parameter to false for situations where the DLL's lifetime - * is controlled in a scope other than that of this ACE_DLL object. - * For example, termination by ACE_DLL_Manager via ACE::fini(). - */ - explicit ACE_DLL (bool close_handle_on_destruction = true); - - /// Allow assignment - ACE_DLL& operator= (const ACE_DLL &rhs); - - - /** - * This constructor performs the actions of open() during construction. - * @param dll_name The name or path of the DLL to load. - * @param open_mode Flags to alter the actions taken when loading the DLL. - * The possible values are: - * @li @c RTLD_LAZY (this the default): loads identifier symbols but - * not the symbols for functions, which are loaded dynamically - * on-demand. - * @li @c RTLD_NOW: performs all necessary relocations when - * @a dll_name is first loaded - * @li RTLD_GLOBAL: makes symbols available for relocation - * processing of any other DLLs. - * @param close_handle_on_destruction Indicates whether or not the - * close() method will be called to close an open DLL when this - * object is destroyed. By default, close() will be called. - * Set this parameter to 0 for situations where the DLL's lifetime - * is controlled in a scope other than that of this ACE_DLL object. - * For example, termination by ACE_DLL_Manager via ACE::fini(). - */ - explicit ACE_DLL (const ACE_TCHAR *dll_name, - int open_mode = ACE_DEFAULT_SHLIB_MODE, - bool close_handle_on_destruction = true); - - /// Copy constructor. - ACE_DLL (const ACE_DLL &); - - /** - * This method opens and dynamically links a specified DLL. - * @param dll_name The filename or path of the DLL to load. ACE will - * attempt to apply the platform's standard library/DLL prefixes - * and suffixes, allowing a simple, unadorned name to be passed - * regardless of platform. The set of name transforms is listed - * below. A @i decorator is a platform's name designator for a debug - * vs release build. For example, on Windows it is usually "d". - * @li Prefix + name + decorator + suffix - * @li Prefix + name + suffix - * @li Name + decorator + suffix - * @li Name + suffix - * @li Name - * Note that the transforms with @i decorator will be avoided if - * ACE is built with the @c ACE_DISABLE_DEBUG_DLL_CHECK config macro. - * - * @Note There is another mode for locating library/DLL files that - * was used in old versions of ACE. The alternate method builds - * more combinations of pathname by combining the names transforms - * above with locations listed in the platform's standard "path" - * locations (e.g., @c LD_LIBRARY_PATH). It can be enabled by building - * ACE with the @c ACE_MUST_HELP_DLOPEN_SEARCH_PATH config macro. - * Use of this option is discouraged since it avoids the standard - * platform search options and security mechanisms. - * - * @param open_mode Flags to alter the actions taken when loading the DLL. - * The possible values are: - * @li @c RTLD_LAZY (this the default): loads identifier symbols but - * not the symbols for functions, which are loaded dynamically - * on demand. - * @li @c RTLD_NOW: performs all necessary relocations when - * @a dll_name is first loaded - * @li @c RTLD_GLOBAL: makes symbols available for relocation - * processing of any other DLLs. - * @param close_handle_on_destruction Indicates whether or not the - * close() method will be called to close an open DLL when this - * object is destroyed. By default, close() will be called. - * Set this parameter to 0 for situations where the DLL's lifetime - * is controlled in a scope other than that of this ACE_DLL object. - * For example, termination by ACE_DLL_Manager via ACE::fini(). - * @retval -1 On failure - * @retval 0 On success. - */ - int open (const ACE_TCHAR *dll_name, - int open_mode = ACE_DEFAULT_SHLIB_MODE, - bool close_handle_on_destruction = true); - - /// Call to close the DLL object. - int close (void); - - /** - * Called when the DLL object is destroyed -- invokes close() if the - * @a close_handle_on_destruction flag was set to non-zero in the - * constructor or open() method. - */ - ~ACE_DLL (void); - - /** - * Look up a named symbol in the DLL. DLL must be successfully opened - * before calling symbol(). - * @param symbol_name The symbol name to look up. - * @param ignore_errors If set to 1, allows you to probe a dll without - * generating error messages in the log. Handy for determining - * the capabilities of a library. - * @return Returns the value of @a symbol_name if it is a valid symbol - * in the DLL. Otherwise, returns 0. - */ - void *symbol (const ACE_TCHAR *symbol_name, int ignore_errors = 0); - - /// Returns a pointer to a string explaining that an error occurred. You - /// will need to consult the error log for the actual error string - /// returned by the OS. - ACE_TCHAR *error (void) const; - - /** - * Return the handle to the caller. If @a become_owner is true then - * caller assumes ownership of the handle and the ACE_DLL object - * won't call close() when it goes out of scope, even if - * @c close_handle_on_destruction is set. - */ - ACE_SHLIB_HANDLE get_handle (bool become_owner = false) const; - - /// Set the handle for the DLL object. By default, the close() - /// operation on / the object will be invoked before it is destroyed. - int set_handle (ACE_SHLIB_HANDLE handle, - bool close_handle_on_destruction = true); - -private: - int open_i (const ACE_TCHAR *dll_name, - int open_mode = ACE_DEFAULT_SHLIB_MODE, - bool close_handle_on_destruction = true, - ACE_SHLIB_HANDLE handle = 0); - - -public: - /// Open mode. - int open_mode_; - - /// Keep track of the name of the loaded dll, so it can be used - /// to remove framework components, singletons that live in the dll, - /// prior to unloading the dll in the close() method. - ACE_TCHAR *dll_name_; - - /// This flag keeps track of whether we should close the handle - /// automatically when the object is destroyed. - bool close_handle_on_destruction_; - - ACE_DLL_Handle *dll_handle_; - - /// Flag to record if the last operation had an error. - bool error_; - - /// Any error messages encountered during last operation. - ACE_TString errmsg_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" -#endif /* ACE_DLL_H */ diff --git a/deps/acelite/ace/DLL_Manager.cpp b/deps/acelite/ace/DLL_Manager.cpp deleted file mode 100644 index 815109789..000000000 --- a/deps/acelite/ace/DLL_Manager.cpp +++ /dev/null @@ -1,803 +0,0 @@ -#include "ace/DLL_Manager.h" - -#include "ace/Auto_Ptr.h" -#include "ace/Log_Category.h" -#include "ace/ACE.h" -#include "ace/Framework_Component.h" - -#include "ace/Lib_Find.h" -#include "ace/Object_Manager.h" -#include "ace/SString.h" -#include "ace/Recursive_Thread_Mutex.h" -#include "ace/Guard_T.h" -#include "ace/OS_NS_dlfcn.h" -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -sig_atomic_t ACE_DLL_Handle::open_called_ = 0; - -ACE_DLL_Handle::ACE_DLL_Handle (void) - : refcount_ (0), - dll_name_ (0), - handle_ (ACE_SHLIB_INVALID_HANDLE) -{ - ACE_TRACE ("ACE_DLL_Handle::ACE_DLL_Handle"); -} - -ACE_DLL_Handle::~ACE_DLL_Handle (void) -{ - ACE_TRACE ("ACE_DLL_Handle::~ACE_DLL_Handle"); - this->close (1); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(this->dll_name_); -#else - delete[] this->dll_name_; -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -ACE_ALLOC_HOOK_DEFINE(ACE_DLL_Handle) - -const ACE_TCHAR * -ACE_DLL_Handle::dll_name (void) const -{ - ACE_TRACE ("ACE_DLL_Handle::dll_name"); - return this->dll_name_; -} - -int -ACE_DLL_Handle::open (const ACE_TCHAR *dll_name, - int open_mode, - ACE_SHLIB_HANDLE handle, - ERROR_STACK *errors) -{ - ACE_TRACE ("ACE_DLL_Handle::open"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); - - if (this->dll_name_) - { - // Once dll_name_ has been set, it can't be changed.. - if (ACE_OS::strcmp (this->dll_name_, dll_name) != 0) - { - if (ACE::debug ()) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) DLL_Handle::open: error, ") - ACE_TEXT ("tried to reopen <%s> with name <%s>\n"), - this->dll_name_, - dll_name)); - - return -1; - } - } - else - this->dll_name_ = ACE::strnew (dll_name); - - if (!this->open_called_) - this->open_called_ = 1; - - // If it hasn't been loaded yet, go ahead and do that now. - if (this->handle_ == ACE_SHLIB_INVALID_HANDLE) - { - if (handle) - this->handle_ = handle; - else - { - /* - ** Get the set of names to try loading. We need to do this to - ** properly support the ability for a user to specify a simple, - ** unadorned name (for example, "ACE") that will work across - ** platforms. We apply platform specifics to get a name that will - ** work (e.g. libACE, ACEd.dll, ACE.dll, etc.) We rely on the - ** underlying dlopen() implementation to "Do The Right Thing" in - ** terms of using relative paths, LD_LIBRARY_PATH, system security - ** rules, etc. except when ACE_MUST_HELP_DLOPEN_SEARCH_PATH is set. - ** If it is set, then ACE::ldfind() scans the configured path - ** looking for a match on the name and prefix/suffix applications. - ** NOTE: having ACE scan for a file and then pass a fully-qualified - ** pathname to dlopen() is a potential security hole; therefore, - ** do not use ACE_MUST_HELP_DLOPEN_SEARCH_PATH unless necessary - ** and only after considering the risks. - */ - ACE_Array dll_names; - dll_names.max_size (10); // Decent guess to avoid realloc later - -#if defined (ACE_MUST_HELP_DLOPEN_SEARCH_PATH) - // Find out where the library is - ACE_TCHAR dll_pathname[MAXPATHLEN + 1]; - - // Transform the pathname into the appropriate dynamic link library - // by searching the ACE_LD_SEARCH_PATH. - ACE::ldfind (dll_name, - dll_pathname, - (sizeof dll_pathname / sizeof (ACE_TCHAR))); - ACE_TString dll_str (dll_pathname); - dll_names.size (1); - dll_names.set (dll_str, 0); -#else - this->get_dll_names (dll_name, dll_names); -#endif - - ACE_TString *name = 0; - for (ACE_Array_Iterator name_iter (dll_names); - name_iter.next (name); name_iter.advance ()) - { - if (this->open_i (name->c_str (), open_mode, errors)) - break; - -#if defined (AIX) -# define SHR_O ACE_TEXT("(shr.o)") -# define SHR_O_LEN (sizeof (SHR_O) / sizeof(ACE_TCHAR) - 1) - // AIX often puts the shared library file (most often named - // shr.o) inside an archive library. If this is an archive - // library name, then try appending [shr.o] and retry. - if (ACE_TString::npos != name->strstr (ACE_TEXT (".a"))) - { - ACE_TCHAR aix_pathname[MAXPATHLEN + 1]; - if (name->length () + SHR_O_LEN <= MAXPATHLEN) - { - ACE_OS::strcpy (aix_pathname, name->c_str()); - ACE_OS::strcat (aix_pathname, SHR_O); - } - else - { - if (errors) - { - errors->push ("path is too long"); - } - - if (ACE::debug ()) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) DLL_Handle::open: ") - ACE_TEXT ("('%s(shr.o)') is too long\n"), - name->c_str())); - } - - return -1; - } - open_mode |= RTLD_MEMBER; - - if (this->open_i (aix_pathname, open_mode)) - break; - } -#endif /* AIX */ - } - - if (this->handle_ == ACE_SHLIB_INVALID_HANDLE) - { - if (ACE::debug ()) - { - ACE_TString errtmp; - this->error (errtmp); - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) DLL_Handle::open (\"%s\"): ") - ACE_TEXT ("Invalid handle error: %s\n"), - this->dll_name_, - errtmp.c_str ())); - } - return -1; - } - } - } - - ++this->refcount_; - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) DLL_Handle::open - <%s> (%d), refcount=%d\n"), - this->dll_name_, - this->handle_, - this->refcount_)); - return 0; -} - - -int -ACE_DLL_Handle::close (int unload) -{ - ACE_TRACE ("ACE_DLL_Handle::close"); - - int retval = 0; - ACE_SHLIB_HANDLE h = ACE_SHLIB_INVALID_HANDLE; - - // Only hold the lock until it comes time to dlclose() the DLL. Closing - // the DLL can cause further shutdowns as DLLs and their dependents are - // unloaded. - { - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); - - // Since we don't actually unload the dll as soon as the refcount - // reaches zero, we need to make sure we don't decrement it below - // zero. - if (this->refcount_ > 0) - --this->refcount_; - else - this->refcount_ = 0; - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) DLL_Handle::close - ") - ACE_TEXT ("<%s> (handle=%d, refcount=%d)\n"), - this->dll_name_, - this->handle_, - this->refcount_)); - - if (this->refcount_ == 0 && - this->handle_ != ACE_SHLIB_INVALID_HANDLE && - unload == 1) - { - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) DLL_Handle::close: ") - ACE_TEXT ("Unloading <%s> (handle=%d)\n"), - this->dll_name_, - this->handle_)); - - // First remove any associated Framework Components. - ACE_Framework_Repository *frPtr= ACE_Framework_Repository::instance (); - if (frPtr) - { - frPtr->remove_dll_components (this->dll_name_); - } - - h = this->handle_; - this->handle_ = ACE_SHLIB_INVALID_HANDLE; - } - } // Release lock_ here - - if (h != ACE_SHLIB_INVALID_HANDLE) - { - retval = ACE_OS::dlclose (h); - - if (retval != 0 && ACE::debug ()) - { - ACE_TString err; - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) DLL_Handle::close - ") - ACE_TEXT ("Failed with: <%s>\n"), - this->error (err).c_str ())); - } - } - - return retval; -} - -sig_atomic_t -ACE_DLL_Handle::refcount (void) const -{ - return this->refcount_; -} - -void * -ACE_DLL_Handle::symbol (const ACE_TCHAR *sym_name, bool ignore_errors) -{ - ACE_TString error; - return this->symbol (sym_name, ignore_errors, error); -} - -void * -ACE_DLL_Handle::symbol (const ACE_TCHAR *sym_name, bool ignore_errors, ACE_TString &error) -{ - ACE_TRACE ("ACE_DLL_Handle::symbol"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); - - ACE_Auto_Array_Ptr auto_name (ACE::ldname (sym_name)); - // handle_ can be invalid especially when ACE_DLL_Handle resigned ownership - // BTW. Handle lifecycle management is a little crazy in ACE - if (this->handle_ != ACE_SHLIB_INVALID_HANDLE) - { -#if defined (ACE_OPENVMS) - void *sym = ACE::ldsymbol (this->handle_, auto_name.get ()); -#else - void *sym = ACE_OS::dlsym (this->handle_, auto_name.get ()); -#endif - - // Linux says that the symbol could be null and that it isn't an - // error. So you should check the error message also, but since - // null symbols won't do us much good anyway, let's still report - // an error. - if (!sym && !ignore_errors) - { - this->error (error); - - if (ACE::debug ()) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) DLL_Handle::symbol <%s>") - ACE_TEXT (" failed with <%s>\n"), - auto_name.get (), - error.c_str ())); - - return 0; - } - return sym; - } - return 0; -} - -ACE_SHLIB_HANDLE -ACE_DLL_Handle::get_handle (bool become_owner) -{ - ACE_TRACE ("ACE_DLL_Handle::get_handle"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); - - if (this->refcount_ == 0 && become_owner) - { - if (ACE::debug ()) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) DLL_Handle::get_handle: ") - ACE_TEXT ("cannot become owner, refcount == 0.\n"))); - - return ACE_SHLIB_INVALID_HANDLE; - } - - ACE_SHLIB_HANDLE handle = this->handle_; - - if (become_owner) - { - if (--this->refcount_ == 0) - this->handle_ = ACE_SHLIB_INVALID_HANDLE; - } - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) DLL_Handle::get_handle: ") - ACE_TEXT ("post call: handle %s, refcount %d\n"), - this->handle_ == ACE_SHLIB_INVALID_HANDLE ? - ACE_TEXT ("invalid") : ACE_TEXT ("valid"), - this->refcount_)); - - return handle; -} - -// This method is used return the last error of a library operation. -ACE_TString & -ACE_DLL_Handle::error (ACE_TString &err) -{ - ACE_TRACE ("ACE_DLL_Handle::error"); - const ACE_TCHAR *error = ACE_OS::dlerror (); - if (error) - { - err = error; - } - return err; -} - -void -ACE_DLL_Handle::get_dll_names (const ACE_TCHAR *dll_name, - ACE_Array &try_names) -{ - // Build the array of DLL names to try on this platform by applying the - // proper prefixes and/or suffixes to the specified dll_name. - ACE_TString base (dll_name); - ACE_TString base_dir, base_file, base_suffix; - - // 1. Separate the dll_name into the dir part and the file part. We - // only decorate the file part to determine the names to try loading. - ACE_TString::size_type pos = base.rfind (ACE_DIRECTORY_SEPARATOR_CHAR); - if (pos != ACE_TString::npos) - { - base_dir = base.substr (0, pos + 1); - base_file = base.substr (pos + 1); - } - else - base_file = base; - - // 2. Locate the file suffix, if there is one. Move the '.' and the - // suffix to base_suffix. - if ((pos = base_file.rfind (ACE_TEXT ('.'))) != ACE_TString::npos) - { - base_suffix = base_file.substr (pos); - base_file = base_file.substr (0, pos); - } - - // 3. Build the combinations to try for this platform. - // Try these combinations: - // - name with platform's dll prefix (if it has one) and suffix - // - name with platform's dll prefix, decorator, and suffix. - // - name with decorator and platform's suffix appended (if not supplied) - // - name with platform's suffix appended (if not supplied) - // - name as originally given - // We first try to find the file using the decorator so that when a - // filename with and without decorator is used, we get the file with - // the same decorator as the ACE dll has and then as last resort - // the one without. For example with msvc, the debug build has a "d" - // decorator, but the release build has none and we really want to get - // the debug version of the library in a debug application instead - // of the release one. - // So we need room for 5 entries in try_names. - try_names.size (0); - if ((try_names.max_size () - try_names.size ()) < 5) - try_names.max_size (try_names.max_size () + 5); -#if defined (ACE_LD_DECORATOR_STR) && !defined (ACE_DISABLE_DEBUG_DLL_CHECK) - ACE_TString decorator (ACE_LD_DECORATOR_STR); -#endif - ACE_TString suffix (ACE_DLL_SUFFIX); - ACE_TString prefix (ACE_DLL_PREFIX); - - for (size_t i = 0; i < 5 && try_names.size () < try_names.max_size (); ++i) - { - ACE_TString try_this; - size_t const j = try_names.size (); - switch (i) - { - case 0: // Prefix + name + decorator + suffix - case 1: // Prefix + name + suffix - case 2: // Name + decorator + suffix - case 3: // Name + suffix - if ( - base_suffix.length () > 0 -#if !(defined (ACE_LD_DECORATOR_STR) && !defined (ACE_DISABLE_DEBUG_DLL_CHECK)) - || (i == 1 || i == 3) // No decorator desired; skip -#endif - ) - break; - try_this = base_dir; - if (i < 2) - try_this += prefix; - try_this += base_file; - if (base_suffix.length () > 0) - try_this += base_suffix; - else - { -#if defined (ACE_LD_DECORATOR_STR) && !defined (ACE_DISABLE_DEBUG_DLL_CHECK) - try_this += decorator; -#endif - try_this += suffix; - } - break; - case 4: - try_this = dll_name; - break; - } - - if (try_this.length ()) - { - try_names.size (j + 1); - try_names.set (try_this, j); - } - } - return; -} - -bool -ACE_DLL_Handle::open_i (const ACE_TCHAR *dll_name, int open_mode, ERROR_STACK* errors) -{ - // The ACE_SHLIB_HANDLE object is obtained. - this->handle_ = ACE_OS::dlopen (dll_name, open_mode); - - if (errors || ACE::debug ()) - { - ACE_TString err; - this->error (err); - if (errors && err.length () > 0) - { - errors->push (err); - } - if (ACE::debug ()) - { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) DLL_Handle::open_i ") - ACE_TEXT ("<%s>, 0x%x) -> <%s>: <%s>\n"), - dll_name, - open_mode, - ((this->handle_ != ACE_SHLIB_INVALID_HANDLE) - ? ACE_TEXT ("succeeded") - : ACE_TEXT ("failed")), - err.c_str ())); - } - } - - return this->handle_ != ACE_SHLIB_INVALID_HANDLE; -} - -/******************************************************************/ - -// Pointer to the Singleton instance. -ACE_DLL_Manager *ACE_DLL_Manager::instance_ = 0; - - -ACE_DLL_Manager * -ACE_DLL_Manager::instance (int size) -{ - ACE_TRACE ("ACE_DLL_Manager::instance"); - - if (ACE_DLL_Manager::instance_ == 0) - { - // Perform Double-Checked Locking Optimization. - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, - *ACE_Static_Object_Lock::instance (), 0)); - if (ACE_DLL_Manager::instance_ == 0) - { - ACE_NEW_RETURN (ACE_DLL_Manager::instance_, - ACE_DLL_Manager (size), - 0); - } - } - - return ACE_DLL_Manager::instance_; -} - -void -ACE_DLL_Manager::close_singleton (void) -{ - ACE_TRACE ("ACE_DLL_Manager::close_singleton"); - - ACE_MT (ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon, - *ACE_Static_Object_Lock::instance ())); - - delete ACE_DLL_Manager::instance_; - ACE_DLL_Manager::instance_ = 0; -} - -ACE_DLL_Manager::ACE_DLL_Manager (int size) - : handle_vector_ (0), - current_size_ (0), - total_size_ (0), - unload_policy_ (ACE_DLL_UNLOAD_POLICY_PER_DLL) -{ - ACE_TRACE ("ACE_DLL_Manager::ACE_DLL_Manager"); - - if (this->open (size) != 0 && ACE::debug ()) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) DLL_Manager ctor failed to allocate ") - ACE_TEXT ("handle_vector_.\n"))); -} - -ACE_DLL_Manager::~ACE_DLL_Manager (void) -{ - ACE_TRACE ("ACE_DLL_Manager::~ACE_DLL_Manager"); - - if (this->close () != 0 && ACE::debug ()) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) DLL_Manager dtor failed to close ") - ACE_TEXT ("properly.\n"))); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_DLL_Manager) - -ACE_DLL_Handle * -ACE_DLL_Manager::open_dll (const ACE_TCHAR *dll_name, - int open_mode, - ACE_SHLIB_HANDLE handle, - ACE_DLL_Handle::ERROR_STACK *errors) -{ - ACE_TRACE ("ACE_DLL_Manager::open_dll"); - - ACE_DLL_Handle *temp_handle = 0; - ACE_DLL_Handle *dll_handle = 0; - { - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); - dll_handle = this->find_dll (dll_name); - if (!dll_handle) - { - if (this->current_size_ < this->total_size_) - { - ACE_NEW_RETURN (temp_handle, - ACE_DLL_Handle, - 0); - - dll_handle = temp_handle; - } - } - } - - if (dll_handle) - { - if (dll_handle->open (dll_name, open_mode, handle, errors) != 0) - { - // Error while opening dll. Free temp handle - if (ACE::debug ()) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) DLL_Manager::open_dll: Could not ") - ACE_TEXT ("open dll <%s>\n"), - dll_name)); - - delete temp_handle; - return 0; - } - - // Add the handle to the vector only if the dll is successfully - // opened. - if (temp_handle != 0) - { - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); - this->handle_vector_[this->current_size_] = dll_handle; - ++this->current_size_; - } - } - - return dll_handle; -} - -int -ACE_DLL_Manager::close_dll (const ACE_TCHAR *dll_name) -{ - ACE_TRACE ("ACE_DLL_Manager::close_dll"); - ACE_DLL_Handle *handle = 0; - - { - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); - handle = this->find_dll (dll_name); - } - - if (handle) - { - return this->unload_dll (handle, 0); - } - - return -1; -} - -u_long -ACE_DLL_Manager::unload_policy (void) const -{ - ACE_TRACE ("ACE_DLL_Manager::unload_policy"); - return this->unload_policy_; -} - -void -ACE_DLL_Manager::unload_policy (u_long unload_policy) -{ - ACE_TRACE ("ACE_DLL_Manager::unload_policy"); - ACE_MT (ACE_GUARD (ACE_Thread_Mutex, ace_mon, this->lock_)); - - u_long old_policy = this->unload_policy_; - this->unload_policy_ = unload_policy; - - // If going from LAZY to EAGER or from PER_DLL to PER_PROCESS|EAGER, - // call close(1) on all the ACE_DLL_Handle objects with refcount == 0 - // which will force those that are still loaded to be unloaded. - if (this->handle_vector_) - if (( ACE_BIT_ENABLED (old_policy, ACE_DLL_UNLOAD_POLICY_LAZY) && - ACE_BIT_DISABLED (this->unload_policy_, ACE_DLL_UNLOAD_POLICY_LAZY) ) || - ( ACE_BIT_DISABLED (this->unload_policy_, ACE_DLL_UNLOAD_POLICY_LAZY) && - ACE_BIT_ENABLED (old_policy, ACE_DLL_UNLOAD_POLICY_PER_DLL) && - ACE_BIT_DISABLED (this->unload_policy_, ACE_DLL_UNLOAD_POLICY_PER_DLL) )) - { - for (int i = this->current_size_ - 1; i >= 0; i--) - { - if (this->handle_vector_[i] && - this->handle_vector_[i]->refcount () == 0) - this->handle_vector_[i]->close (1); - } - } -} - -int -ACE_DLL_Manager::open (int size) -{ - ACE_TRACE ("ACE_DLL_Manager::open"); - - ACE_DLL_Handle **temp = 0; - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (temp, - static_cast (ACE_Allocator::instance()->malloc(sizeof (ACE_DLL_Handle*) * size)), - -1); -#else - ACE_NEW_RETURN (temp, - ACE_DLL_Handle *[size], - -1); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - this->handle_vector_ = temp; - this->total_size_ = size; - return 0; -} - -int -ACE_DLL_Manager::close (void) -{ - ACE_TRACE ("ACE_DLL_Manager::close"); - - int force_close = 1; - - if (this->handle_vector_ != 0) - { - // Delete components in reverse order. - for (int i = this->current_size_ - 1; i >= 0; i--) - { - if (this->handle_vector_[i]) - { - ACE_DLL_Handle *s = - const_cast (this->handle_vector_[i]); - this->handle_vector_[i] = 0; - this->unload_dll (s, force_close); - delete s; - } - } - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(this->handle_vector_); -#else - delete [] this->handle_vector_; -#endif /* ACE_HAS_ALLOC_HOOKS */ - - this->handle_vector_ = 0; - this->current_size_ = 0; - } - return 0; -} - -ACE_DLL_Handle * -ACE_DLL_Manager::find_dll (const ACE_TCHAR *dll_name) const -{ - ACE_TRACE ("ACE_DLL_Manager::find_dll"); - - for (int i = 0; i < this->current_size_; i++) - if (this->handle_vector_[i] && - ACE_OS::strcmp (this->handle_vector_[i]->dll_name (), dll_name) == 0) - { - return this->handle_vector_[i]; - } - - return 0; -} - -int -ACE_DLL_Manager::unload_dll (ACE_DLL_Handle *dll_handle, int force_unload) -{ - ACE_TRACE ("ACE_DLL_Manager::unload_dll"); - - if (dll_handle) - { - int unload = force_unload; - if (unload == 0) - { - // apply strategy - if (ACE_BIT_DISABLED (this->unload_policy_, - ACE_DLL_UNLOAD_POLICY_PER_DLL)) - { - unload = ACE_BIT_DISABLED (this->unload_policy_, - ACE_DLL_UNLOAD_POLICY_LAZY); - } - else - { - // Declare the type of the symbol: - typedef int (*dll_unload_policy)(void); - - void * const unload_policy_ptr = - dll_handle->symbol (ACE_TEXT ("_get_dll_unload_policy"), 1); -#if defined (ACE_OPENVMS) && (!defined (__INITIAL_POINTER_SIZE) || (__INITIAL_POINTER_SIZE < 64)) - int const temp_p = - reinterpret_cast (unload_policy_ptr); -#else - intptr_t const temp_p = - reinterpret_cast (unload_policy_ptr); -#endif - - dll_unload_policy const the_policy = - reinterpret_cast (temp_p); - - if (the_policy != 0) - unload = ACE_BIT_DISABLED (the_policy (), - ACE_DLL_UNLOAD_POLICY_LAZY); - else - unload = ACE_BIT_DISABLED (this->unload_policy_, - ACE_DLL_UNLOAD_POLICY_LAZY); - } - } - - if (dll_handle->close (unload) != 0) - { - if (ACE::debug ()) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) DLL_Manager::unload error.\n"))); - - return -1; - } - } - else - { - if (ACE::debug ()) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) DLL_Manager::unload_dll called with ") - ACE_TEXT ("null pointer.\n"))); - - return -1; - } - - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/DLL_Manager.h b/deps/acelite/ace/DLL_Manager.h deleted file mode 100644 index 3a98d2200..000000000 --- a/deps/acelite/ace/DLL_Manager.h +++ /dev/null @@ -1,321 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file DLL_Manager.h - * - * @author Don Hinton - */ -//============================================================================= - -#ifndef ACE_DLL_MANAGER_H -#define ACE_DLL_MANAGER_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Containers_T.h" -#include "ace/SString.h" -#include "ace/os_include/os_dlfcn.h" - -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) -# include "ace/Thread_Mutex.h" -#endif /* ACE_MT_SAFE */ - -#define ACE_DEFAULT_DLL_MANAGER_SIZE 1024 - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_DLL_Handle - * - * @brief Provides an abstract interface for handling various DLL - * operations. - * - * This class is an wrapper over the various methods for utilizing a - * dynamically linked library (DLL), which is called a shared library - * on some platforms. It is refcounted and managed by - * ACE_DLL_Manager, so there will only be a single instance of this - * class for each dll loaded, no matter how many instances of ACE_DLL - * an application has open. Operations open(), close(), and symbol() - * have been implemented to help opening/closing and extracting symbol - * information from a DLL, respectively. - * - * Most of this class came from the original ACE_DLL class. ACE_DLL - * is now just an interface that passed all it's calls either directly - * or via ACE_DLL_Manager to this class for execution. - */ -class ACE_Export ACE_DLL_Handle -{ -public: - /// Error stack. Fixed size should suffice. Ignores any errors exceeding the size. - typedef ACE_Fixed_Stack ERROR_STACK; - - /// Default construtor. - ACE_DLL_Handle (void); - - /// Destructor. - ~ACE_DLL_Handle (void); - - /// Returns the name of the shared library (without prefixes or suffixes). - const ACE_TCHAR *dll_name () const; - - /** - * This method opens and dynamically links a library/DLL. - * @param dll_name The filename or path of the DLL to load. ACE will - * attempt to apply the platform's standard library/DLL prefixes - * and suffixes, allowing a simple, unadorned name to be passed - * regardless of platform. The set of name transforms is listed - * below. A @i decorator is a platform's name designator for a debug - * vs release build. For example, on Windows it is usually "d". - * @li Prefix + name + decorator + suffix - * @li Prefix + name + suffix - * @li Name + decorator + suffix - * @li Name + suffix - * @li Name - * Note that the transforms with @i decorator will be avoided if - * ACE is built with the @c ACE_DISABLE_DEBUG_DLL_CHECK config macro. - * - * @Note There is another mode for locating library/DLL files that - * was used in old versions of ACE. The alternate method builds - * more combinations of pathname by combining the names transforms - * above with locations listed in the platform's standard "path" - * locations (e.g., @c LD_LIBRARY_PATH). It can be enabled by building - * ACE with the @c ACE_MUST_HELP_DLOPEN_SEARCH_PATH config macro. - * Use of this option is discouraged since it avoids the standard - * platform search options and security mechanisms. - * - * @param open_mode Flags to alter the actions taken when loading the DLL. - * The possible values are: - * @li @c RTLD_LAZY (this the default): loads identifier symbols but - * not the symbols for functions, which are loaded dynamically - * on demand. - * @li @c RTLD_NOW: performs all necessary relocations when - * @a dll_name is first loaded - * @li @c RTLD_GLOBAL: makes symbols available for relocation - * processing of any other DLLs. - * @param handle If a value other than @c ACE_INVALID_HANDLE is supplied, - * this object is assigned the specified handle instead of attempting - * to open the specified @a dll_name. - * @param errors Optional address of an error stack to collect any errors - * encountered. - * @retval -1 On failure - * @retval 0 On success. - */ - int open (const ACE_TCHAR *dll_name, - int open_mode, - ACE_SHLIB_HANDLE handle, - ERROR_STACK *errors = 0); - - /// Call to close the DLL object. If unload = 0, it only decrements - /// the refcount, but if unload = 1, then it will actually unload - /// the library when the refcount == 0; - int close (int unload = 0); - - /// Return the current refcount. - sig_atomic_t refcount (void) const; - - /// If @a symbol_name is in the symbol table of the DLL a pointer to - /// the @a symbol_name is returned. Otherwise, returns 0. Set the - /// ignore_errors flag to supress logging errors if symbol_name isn't - /// found. This is nice if you just want to probe a dll to see what's - /// available, since missing functions in that case aren't really errors. - void *symbol (const ACE_TCHAR *symbol_name, bool ignore_errors = false); - - /// Resolves and returns any error encountered. - void *symbol (const ACE_TCHAR *symbol_name, bool ignore_errors, - ACE_TString &error); - - /** - * Return the handle to the caller. If @a become_owner is true then - * caller assumes ownership of the handle so we decrement the retcount. - */ - ACE_SHLIB_HANDLE get_handle (bool become_owner = false); - - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Returns a string explaining why or - /// failed in @a err. This is used internal to print out the error to the log, - /// but since this object is shared, we can't store or return the error - /// to the caller. - ACE_TString& error (ACE_TString& err); - - /// Builds array of DLL names to try to dlopen, based on platform - /// and configured DLL prefixes/suffixes. - /// Returns the array of names to try in try_names. - void get_dll_names (const ACE_TCHAR *dll_name, - ACE_Array &try_names); - - /** - * This method opens and dynamically links a library/DLL. - * @param dll_name The filename or path of the DLL to load. - * @param open_mode Flags to alter the actions taken when loading the DLL. - * The possible values are: - * @li @c RTLD_LAZY (this the default): loads identifier symbols but - * not the symbols for functions, which are loaded dynamically - * on demand. - * @li @c RTLD_NOW: performs all necessary relocations when - * @a dll_name is first loaded - * @li @c RTLD_GLOBAL: makes symbols available for relocation - * processing of any other DLLs. - * @param errors Optional address of an error stack to collect any errors - * encountered. - * @retval false On failure - * @retval true On success - */ - bool open_i (const ACE_TCHAR *dll_name, int open_mode, ERROR_STACK* errors); - - /// Disallow copying and assignment since we don't handle them. - ACE_DLL_Handle (const ACE_DLL_Handle &); - void operator= (const ACE_DLL_Handle &); - -private: - /// Keep track of how many ACE_DLL objects have a reference to this - /// dll. - sig_atomic_t refcount_; - - /// Name of the shared library. - ACE_TCHAR *dll_name_; - - /// Handle to the actual library loaded by the OS. - ACE_SHLIB_HANDLE handle_; - - /// Keeps track of whether or not open() has ever been called. This - /// helps get around problem on Linux, and perhaps other OS's, that - /// seg-fault if dlerror() is called before the ld library has been - /// initialized by a call to dlopen(). - static sig_atomic_t open_called_; - -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - /// Synchronization variable for the MT_SAFE Repository - ACE_Thread_Mutex lock_; -#endif /* ACE_MT_SAFE */ -}; - -class ACE_Framework_Repository; - -/** - * @class ACE_DLL_Manager - * - * @brief This class is a singleton and serves as a factory and - * repository for instances of ACE_DLL_Handle. - * - * This class is a singleton whose lifetime is managed by the - * ACE_Framework_Repository. Although it is normally meant to be - * used directly only by ACE_DLL, applications can call the unload_policy() - * methods in order get/set the the dll unload policy. Unload policies include - * per_process/per-dll and eager/lazy. Dlls can export set their own policy - * by using the ACE_DLL_UNLOAD_POLICY macro found in config-all.h. If a dll - * choses to set an unload policy, it will be used when the per-dll policy - * (the default) is in effect. If the per-dll policy is in effect and a dll - * has not chosen to set a policy, the current per-process policy will be - * used. - * - * The following policy macros are provided in config-all.h: - * - * ACE_DLL_UNLOAD_POLICY_PER_PROCESS - Per-process policy that unloads dlls - * eagerly. - * - * ACE_DLL_UNLOAD_POLICY_PER_DLL - Apply policy on a per-dll basis. If the - * dll doesn't use one of the macros below, the current per-process policy - * will be used. - * - * ACE_DLL_UNLOAD_POLICY_LAZY - Don't unload dll when refcount reaches - * zero, i.e., wait for either an explicit unload request or program exit. - * - * ACE_DLL_UNLOAD_POLICY_DEFAULT - Default policy allows dlls to control - * their own destinies, but will unload those that don't make a choice eagerly. - */ -class ACE_Export ACE_DLL_Manager -{ -public: - friend class ACE_Framework_Repository; - friend class ACE_Object_Manager; - - enum - { - DEFAULT_SIZE = ACE_DEFAULT_DLL_MANAGER_SIZE - }; - - /// Return a unique instance - static ACE_DLL_Manager *instance (int size = ACE_DLL_Manager::DEFAULT_SIZE); - - /// Factory for ACE_DLL_Handle objects. If one already exits, - /// its refcount is incremented. - ACE_DLL_Handle *open_dll (const ACE_TCHAR *dll_name, - int openmode, - ACE_SHLIB_HANDLE handle, - ACE_DLL_Handle::ERROR_STACK *errors = 0); - - /// Close the underlying dll. Decrements the refcount. - int close_dll (const ACE_TCHAR *dll_name); - - /// Returns the current per-process UNLOAD_POLICY. - u_long unload_policy (void) const; - - /// Set the per-process UNLOAD_POLICY. If the policy is changed from - /// LAZY to EAGER, then it will also unload any dlls with zero - /// refcounts. - void unload_policy (u_long unload_policy); - - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Default constructor. - ACE_DLL_Manager (int size = ACE_DLL_Manager::DEFAULT_SIZE); - - /// Destructor. - ~ACE_DLL_Manager (void); - - /// Allocate handle_vector_. - int open (int size); - - /// Close all open dlls and deallocate memory. - int close (void); - - /// Find dll in handle_vector_. - ACE_DLL_Handle *find_dll (const ACE_TCHAR *dll_name) const; - - /// Applies strategy for unloading dll. - int unload_dll (ACE_DLL_Handle *dll_handle, int force_unload = 0); - -private: - /// Close the singleton instance. - static void close_singleton (void); - - /// Disallow copying and assignment since we don't handle these. - ACE_DLL_Manager (const ACE_DLL_Manager &); - void operator= (const ACE_DLL_Manager &); - -private: - /// Vector containing all loaded handle objects. - ACE_DLL_Handle **handle_vector_; - - /// Current number of handles. - int current_size_; - - /// Maximum number of handles. - int total_size_; - - /// Unload strategy. - u_long unload_policy_; - - /// Pointer to a process-wide ACE_DLL_Manager. - static ACE_DLL_Manager *instance_; - -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - /// Synchronization variable for the MT_SAFE Repository - ACE_Thread_Mutex lock_; -#endif /* ACE_MT_SAFE */ - -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" -#endif /* ACE_DLL_MANAGER_H */ diff --git a/deps/acelite/ace/Date_Time.cpp b/deps/acelite/ace/Date_Time.cpp deleted file mode 100644 index 8d84df812..000000000 --- a/deps/acelite/ace/Date_Time.cpp +++ /dev/null @@ -1,8 +0,0 @@ -// Date_Time.cpp -#include "ace/Date_Time.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Date_Time.inl" -#endif /* __ACE_INLINE__ */ - - diff --git a/deps/acelite/ace/Date_Time.h b/deps/acelite/ace/Date_Time.h deleted file mode 100644 index aba5d0448..000000000 --- a/deps/acelite/ace/Date_Time.h +++ /dev/null @@ -1,122 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Date_Time.h - * - * @author Tim Harrison (harrison@cs.wustl.edu) (and he's darn proud of this ;-)) - */ -//========================================================================== - -#ifndef ACE_DATE_TIME_H -#define ACE_DATE_TIME_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Time_Value; - -/** - * @class ACE_Date_Time - * - * @brief System independent representation of date and time. - */ -class ACE_Export ACE_Date_Time -{ -public: - /// Constructor initializes current time/date info. - ACE_Date_Time (void); - - /// Constructor initializes with the given ACE_Time_Value - explicit ACE_Date_Time (const ACE_Time_Value& timevalue); - - /// Constructor with init values, no check for validy - /// Set/get portions of ACE_Date_Time, no check for validity. - ACE_Date_Time (long day, - long month = 0, - long year = 0, - long hour = 0, - long minute = 0, - long second = 0, - long microsec = 0, - long wday = 0); - - /// Update to the current time/date. - void update (void); - - /// Update to the given ACE_Time_Value - void update (const ACE_Time_Value& timevalue); - - /// Get day. - long day (void) const; - - /// Set day. - void day (long day); - - /// Get month. - long month (void) const; - - /// Set month. - void month (long month); - - /// Get year. - long year (void) const; - - /// Set year. - void year (long year); - - /// Get hour. - long hour (void) const; - - /// Set hour. - void hour (long hour); - - /// Get minute. - long minute (void) const; - - /// Set minute. - void minute (long minute); - - /// Get second. - long second (void) const; - - /// Set second. - void second (long second); - - /// Get microsec. - long microsec (void) const; - - /// Set microsec. - void microsec (long microsec); - - /// Get weekday. - long weekday (void) const; - - /// Set weekday. - void weekday (long wday); - -private: - long day_; - long month_; - long year_; - long hour_; - long minute_; - long second_; - long microsec_; - long wday_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Date_Time.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_DATE_TIME_H */ diff --git a/deps/acelite/ace/Date_Time.inl b/deps/acelite/ace/Date_Time.inl deleted file mode 100644 index 196f572be..000000000 --- a/deps/acelite/ace/Date_Time.inl +++ /dev/null @@ -1,216 +0,0 @@ -// -*- C++ -*- -#include "ace/Global_Macros.h" -#include "ace/Time_Value.h" -#include "ace/OS_NS_sys_time.h" -#include "ace/OS_NS_time.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE void -ACE_Date_Time::update (const ACE_Time_Value& timevalue) -{ -#if defined (ACE_HAS_WINCE) - // CE doesn't do localtime(). - FILETIME file_time = timevalue; - FILETIME local_file_time; - SYSTEMTIME sys_time; - ::FileTimeToLocalFileTime (&file_time, &local_file_time); - ::FileTimeToSystemTime (&local_file_time, &sys_time); - this->day_ = sys_time.wDay; - this->month_ = sys_time.wMonth; - this->year_ = sys_time.wYear; - this->hour_ = sys_time.wHour; - this->minute_ = sys_time.wMinute; - this->second_ = sys_time.wSecond; - this->microsec_ = sys_time.wMilliseconds * 1000; - this->wday_ = sys_time.wDayOfWeek; -#else - time_t time = timevalue.sec (); - struct tm tm_time; - ACE_OS::localtime_r (&time, &tm_time); - this->day_ = tm_time.tm_mday; - this->month_ = tm_time.tm_mon + 1; // localtime's months are 0-11 - this->year_ = tm_time.tm_year + 1900; // localtime reports years since 1900 - this->hour_ = tm_time.tm_hour; - this->minute_ = tm_time.tm_min; - this->second_ = tm_time.tm_sec; - this->microsec_ = timevalue.usec (); - this->wday_ = tm_time.tm_wday; -#endif /* ACE_HAS_WINCE */ -} - -ACE_INLINE void -ACE_Date_Time::update (void) -{ - ACE_TRACE ("ACE_Date_Time::update"); - - update(ACE_OS::gettimeofday ()); -} - -ACE_INLINE -ACE_Date_Time::ACE_Date_Time (void) -{ - ACE_TRACE ("ACE_Date_Time::ACE_Date_Time"); - this->update (); -} - -ACE_INLINE -ACE_Date_Time::ACE_Date_Time (const ACE_Time_Value& timevalue) -{ - ACE_TRACE ("ACE_Date_Time::ACE_Date_Time: timevalue"); - this->update (timevalue); -} - -// Constructor with init values, no check for validy -ACE_INLINE -ACE_Date_Time::ACE_Date_Time (long day, - long month, - long year, - long hour, - long minute, - long second, - long microsec, - long wday) - : day_ (day), - month_ (month), - year_ (year), - hour_ (hour), - minute_ (minute), - second_ (second), - microsec_ (microsec), - wday_ (wday) -{ - ACE_TRACE ("ACE_Date_Time::ACE_Date_Time"); -} - -// set/get portions of ACE_Date_Time, no check for validy - -// get day -ACE_INLINE long -ACE_Date_Time::day (void) const -{ - ACE_TRACE ("ACE_Date_Time::day"); - return day_; -} - -// set day -ACE_INLINE void -ACE_Date_Time::day (long day) -{ - ACE_TRACE ("ACE_Date_Time::day"); - day_ = day; -} - -// get month -ACE_INLINE long -ACE_Date_Time::month (void) const -{ - ACE_TRACE ("ACE_Date_Time::month"); - return month_; -} - -// set month -ACE_INLINE void -ACE_Date_Time::month (long month) -{ - ACE_TRACE ("ACE_Date_Time::month"); - month_ = month; -} - -// get year -ACE_INLINE long -ACE_Date_Time::year (void) const -{ - ACE_TRACE ("ACE_Date_Time::year"); - return year_; -} - -// set year -ACE_INLINE void -ACE_Date_Time::year (long year) -{ - ACE_TRACE ("ACE_Date_Time::year"); - year_ = year; -} - -// get hour -ACE_INLINE long -ACE_Date_Time::hour (void) const -{ - ACE_TRACE ("ACE_Date_Time::hour"); - return hour_; -} - -// set hour -ACE_INLINE void -ACE_Date_Time::hour (long hour) -{ - ACE_TRACE ("ACE_Date_Time::hour"); - hour_ = hour; -} - -// get minute -ACE_INLINE long -ACE_Date_Time::minute (void) const -{ - ACE_TRACE ("ACE_Date_Time::minute"); - return minute_; -} - -// set minute -ACE_INLINE void -ACE_Date_Time::minute (long minute) -{ - ACE_TRACE ("ACE_Date_Time::minute"); - minute_ = minute; -} - -// get second -ACE_INLINE long -ACE_Date_Time::second (void) const -{ - ACE_TRACE ("ACE_Date_Time::second"); - return second_; -} - -// set second -ACE_INLINE void -ACE_Date_Time::second (long second) -{ - ACE_TRACE ("ACE_Date_Time::second"); - second_ = second; -} - -// get microsec -ACE_INLINE long -ACE_Date_Time::microsec (void) const -{ - ACE_TRACE ("ACE_Date_Time::microsec"); - return microsec_; -} - -// set microsec -ACE_INLINE void -ACE_Date_Time::microsec (long microsec) -{ - ACE_TRACE ("ACE_Date_Time::microsec"); - microsec_ = microsec; -} - -// get wday -ACE_INLINE long -ACE_Date_Time::weekday (void) const -{ - ACE_TRACE ("ACE_Date_Time::weekday"); - return wday_; -} - -// set wday -ACE_INLINE void -ACE_Date_Time::weekday (long wday) -{ - ACE_TRACE ("ACE_Date_Time::weekday"); - wday_ = wday; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Default_Constants.h b/deps/acelite/ace/Default_Constants.h deleted file mode 100644 index 383679a1e..000000000 --- a/deps/acelite/ace/Default_Constants.h +++ /dev/null @@ -1,592 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Default_Constants.h - * - * @author Douglas C. Schmidt - * @author Jesper S. M|ller - * @author and a cast of thousands... - * - * This one is split from the famous OS.h - */ -//============================================================================= - -#ifndef ACE_DEFAULT_CONSTANTS_H -#define ACE_DEFAULT_CONSTANTS_H -#include /**/ "ace/pre.h" - -// Included just keep compilers that see #pragma directive first -// happy. -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -// For _POSIX_TIMER_MAX -#include "ace/os_include/os_limits.h" - -// Define the default constants for ACE. Many of these are used for -// the ACE tests and applications. You can change these values by -// defining the macros in your config.h file. -# if !defined (ACE_DEFAULT_CLOSE_ALL_HANDLES) -# define ACE_DEFAULT_CLOSE_ALL_HANDLES true -# endif /* ACE_DEFAULT_CLOSE_ALL_HANDLES */ - -// The maximum length for a fully qualified Internet name. -# if !defined(ACE_MAX_FULLY_QUALIFIED_NAME_LEN) -# define ACE_MAX_FULLY_QUALIFIED_NAME_LEN 256 -# endif /* ACE_MAX_FULLY_QUALIFIED_NAME_LEN */ - -#if !defined (ACE_DEFAULT_PAGEFILE_POOL_BASE) -#define ACE_DEFAULT_PAGEFILE_POOL_BASE (void *) 0 -#endif /* ACE_DEFAULT_PAGEFILE_POOL_BASE */ - -#if !defined (ACE_DEFAULT_PAGEFILE_POOL_SIZE) -#define ACE_DEFAULT_PAGEFILE_POOL_SIZE (size_t) 0x01000000 -#endif /* ACE_DEFAULT_PAGEFILE_POOL_SIZE */ - -#if !defined (ACE_DEFAULT_PAGEFILE_POOL_CHUNK) -#define ACE_DEFAULT_PAGEFILE_POOL_CHUNK (size_t) 0x00010000 -#endif /* ACE_DEFAULT_PAGEFILE_POOL_CHUNK */ - -#if !defined (ACE_DEFAULT_PAGEFILE_POOL_NAME) -#define ACE_DEFAULT_PAGEFILE_POOL_NAME ACE_TEXT ("Default_ACE_Pagefile_Memory_Pool") -#endif /* ACE_DEFAULT_PAGEFILE_POOL_NAME */ - -#if !defined (ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY) -#define ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY 0 -#endif /* ACE_DEFAULT_MESSAGE_BLOCK_PRIORITY */ - -#if !defined (ACE_DEFAULT_SERVICE_REPOSITORY_SIZE) -#define ACE_DEFAULT_SERVICE_REPOSITORY_SIZE 1024 -#endif /* ACE_DEFAULT_SERVICE_REPOSITORY_SIZE */ - -#if !defined (ACE_DEFAULT_SERVICE_GESTALT_SIZE) -#define ACE_DEFAULT_SERVICE_GESTALT_SIZE 1024 -#endif /* ACE_DEFAULT_SERVICE_GESTALT_SIZE */ - -#if !defined (ACE_REACTOR_NOTIFICATION_ARRAY_SIZE) -#define ACE_REACTOR_NOTIFICATION_ARRAY_SIZE 1024 -#endif /* ACE_REACTOR_NOTIFICATION_ARRAY_SIZE */ - -# if !defined (ACE_DEFAULT_TIMEOUT) -# define ACE_DEFAULT_TIMEOUT 5 -# endif /* ACE_DEFAULT_TIMEOUT */ - -# if !defined (ACE_DEFAULT_BACKLOG) -# define ACE_DEFAULT_BACKLOG 5 -# endif /* ACE_DEFAULT_BACKLOG */ - -# if !defined (ACE_DEFAULT_ASYNCH_BACKLOG) -# define ACE_DEFAULT_ASYNCH_BACKLOG 5 -# endif /* ACE_DEFAULT_ASYNCH_BACKLOG */ - -# if !defined (ACE_DEFAULT_THREADS) -# define ACE_DEFAULT_THREADS 1 -# endif /* ACE_DEFAULT_THREADS */ - -// The following 3 defines are used in the IP multicast and broadcast tests. -# if !defined (ACE_DEFAULT_BROADCAST_PORT) -# define ACE_DEFAULT_BROADCAST_PORT 20000 -# endif /* ACE_DEFAULT_BROADCAST_PORT */ - -# if !defined (ACE_DEFAULT_MULTICAST_PORT) -# define ACE_DEFAULT_MULTICAST_PORT 20001 -# endif /* ACE_DEFAULT_MULTICAST_PORT */ - -# if !defined (ACE_DEFAULT_MULTICAST_ADDR) -// This address MUST be within the range for host group addresses: -// 224.0.0.0 to 239.255.255.255. -# define ACE_DEFAULT_MULTICAST_ADDR "224.9.9.2" -# endif /* ACE_DEFAULT_MULTICAST_ADDR */ - -# if defined (ACE_HAS_IPV6) -# if !defined (ACE_DEFAULT_MULTICASTV6_ADDR) -// This address should be within the range for site-local addresses: -// ff05::0/16 . -# define ACE_DEFAULT_MULTICASTV6_ADDR "ff05:0::ff01:1" -# endif /* ACE_DEFAULT_MULTICASTV6_ADDR */ -# endif - -// Default port number for HTTP. -# if !defined (ACE_DEFAULT_HTTP_SERVER_PORT) -# define ACE_DEFAULT_HTTP_SERVER_PORT 80 -# endif /* ACE_DEFAULT_HTTP_SERVER_PORT */ - -// Used in many IPC_SAP tests -# if !defined (ACE_DEFAULT_SERVER_PORT) -# define ACE_DEFAULT_SERVER_PORT 20002 -# endif /* ACE_DEFAULT_SERVER_PORT */ - -# if !defined (ACE_DEFAULT_HTTP_PORT) -# define ACE_DEFAULT_HTTP_PORT 80 -# endif /* ACE_DEFAULT_HTTP_PORT */ - -# if !defined (ACE_DEFAULT_MAX_SOCKET_BUFSIZ) -# define ACE_DEFAULT_MAX_SOCKET_BUFSIZ 65536 -# endif /* ACE_DEFAULT_MAX_SOCKET_BUFSIZ */ - -# if !defined (ACE_DEFAULT_SERVER_PORT_STR) -# define ACE_DEFAULT_SERVER_PORT_STR ACE_TEXT("20002") -# endif /* ACE_DEFAULT_SERVER_PORT_STR */ - -// Used for the Service_Directory test -# if !defined (ACE_DEFAULT_SERVICE_PORT) -# define ACE_DEFAULT_SERVICE_PORT 20003 -# endif /* ACE_DEFAULT_SERVICE_PORT */ - -// Used for the ACE_Thread_Spawn test -# if !defined (ACE_DEFAULT_THR_PORT ) -# define ACE_DEFAULT_THR_PORT 20004 -# endif /* ACE_DEFAULT_THR_PORT */ - -// Used for tests -# if !defined (ACE_DEFAULT_LOCAL_PORT) -# define ACE_DEFAULT_LOCAL_PORT 20005 -# endif /* ACE_DEFAULT_LOCAL_PORT */ - -// Used for Connector tests -# if !defined (ACE_DEFAULT_LOCAL_PORT_STR) -# define ACE_DEFAULT_LOCAL_PORT_STR "20005" -# endif /* ACE_DEFAULT_LOCAL_PORT_STR */ - -// Used for the name server. -# if !defined (ACE_DEFAULT_NAME_SERVER_PORT) -# define ACE_DEFAULT_NAME_SERVER_PORT 20006 -# endif /* ACE_DEFAULT_NAME_SERVER_PORT */ - -# if !defined (ACE_DEFAULT_NAME_SERVER_PORT_STR) -# define ACE_DEFAULT_NAME_SERVER_PORT_STR "20006" -# endif /* ACE_DEFAULT_NAME_SERVER_PORT_STR */ - -// Used for the token server. -# if !defined (ACE_DEFAULT_TOKEN_SERVER_PORT) -# define ACE_DEFAULT_TOKEN_SERVER_PORT 20007 -# endif /* ACE_DEFAULT_TOKEN_SERVER_PORT */ - -# if !defined (ACE_DEFAULT_TOKEN_SERVER_PORT_STR) -# define ACE_DEFAULT_TOKEN_SERVER_PORT_STR "20007" -# endif /* ACE_DEFAULT_TOKEN_SERVER_PORT_STR */ - -// Used for the logging server. -# if !defined (ACE_DEFAULT_LOGGING_SERVER_PORT) -# define ACE_DEFAULT_LOGGING_SERVER_PORT 20008 -# endif /* ACE_DEFAULT_LOGGING_SERVER_PORT */ - -# if !defined (ACE_DEFAULT_LOGGING_SERVER_PORT_STR) -# define ACE_DEFAULT_LOGGING_SERVER_PORT_STR "20008" -# endif /* ACE_DEFAULT_LOGGING_SERVER_PORT_STR */ - -// Used for the logging server. -# if !defined (ACE_DEFAULT_THR_LOGGING_SERVER_PORT) -# define ACE_DEFAULT_THR_LOGGING_SERVER_PORT 20008 -# endif /* ACE_DEFAULT_THR_LOGGING_SERVER_PORT */ - -# if !defined (ACE_DEFAULT_THR_LOGGING_SERVER_PORT_STR) -# define ACE_DEFAULT_THR_LOGGING_SERVER_PORT_STR "20008" -# endif /* ACE_DEFAULT_THR_LOGGING_SERVER_PORT_STR */ - -// Used for the time server. -# if !defined (ACE_DEFAULT_TIME_SERVER_PORT) -# define ACE_DEFAULT_TIME_SERVER_PORT 20009 -# endif /* ACE_DEFAULT_TIME_SERVER_PORT */ - -# if !defined (ACE_DEFAULT_TIME_SERVER_PORT_STR) -# define ACE_DEFAULT_TIME_SERVER_PORT_STR "20009" -# endif /* ACE_DEFAULT_TIME_SERVER_PORT_STR */ - -# if !defined (ACE_DEFAULT_TIME_SERVER_STR) -# define ACE_DEFAULT_TIME_SERVER_STR "ACE_TS_TIME" -# endif /* ACE_DEFAULT_TIME_SERVER_STR */ - -// Used by the FIFO tests -# if !defined (ACE_DEFAULT_RENDEZVOUS) -# if defined (ACE_HAS_STREAM_PIPES) -# define ACE_DEFAULT_RENDEZVOUS ACE_TEXT("/tmp/fifo.ace") -# else -# define ACE_DEFAULT_RENDEZVOUS ACE_TEXT("localhost:20010") -# endif /* ACE_HAS_STREAM_PIPES */ -# endif /* ACE_DEFAULT_RENDEZVOUS */ - -// Used for the UNIX syslog logging interface to ACE_Log_Msg. -# ifndef ACE_DEFAULT_SYSLOG_FACILITY -# define ACE_DEFAULT_SYSLOG_FACILITY LOG_USER -# endif /* ACE_DEFAULT_SYSLOG_FACILITY */ - -# if !defined (ACE_HAS_STREAM_LOG_MSG_IPC) -# if defined (ACE_HAS_STREAM_PIPES) -# define ACE_HAS_STREAM_LOG_MSG_IPC 1 -# else -# define ACE_HAS_STREAM_LOG_MSG_IPC 0 -# endif /* ACE_HAS_STREAM_PIPES */ -# endif /* !ACE_HAS_STREAM_LOG_MSG_IPC */ - -# if !defined (ACE_DEFAULT_LOGGER_KEY) -# if (ACE_HAS_STREAM_LOG_MSG_IPC == 1) -# define ACE_DEFAULT_LOGGER_KEY ACE_TEXT ("/tmp/server_daemon") -# else -# define ACE_DEFAULT_LOGGER_KEY ACE_TEXT ("localhost:20012") -# endif /* ACE_HAS_STREAM_LOG_MSG_IPC==1 */ -# endif /* ACE_DEFAULT_LOGGER_KEY */ - -// The way to specify the local host for loopback IP. This is usually -// "localhost" but it may need changing on some platforms. -# if !defined (ACE_LOCALHOST) -# define ACE_LOCALHOST ACE_TEXT ("localhost") -# endif - -// This specification for an IPv6 localhost should work on all platforms -// supporting IPv6 -# if defined (ACE_HAS_IPV6) -# if !defined (ACE_IPV6_LOCALHOST) -# define ACE_IPV6_LOCALHOST ACE_TEXT ("::1") -# endif /* ACE_IPV6_LOCALHOST*/ -#endif /* ACE_HAS_IPV6 */ - -// This specification for an IPv6 ANY address should work on all platforms -// supporting IPv6 -# if defined (ACE_HAS_IPV6) -# if !defined (ACE_IPV6_ANY) -# define ACE_IPV6_ANY ACE_TEXT ("::") -# endif /* ACE_IPV6_ANY*/ -#endif /* ACE_HAS_IPV6 */ - -# if !defined (ACE_DEFAULT_SERVER_HOST) -# if defined (ACE_HAS_IPV6) -# define ACE_DEFAULT_SERVER_HOST ACE_IPV6_LOCALHOST -# else /*ACE_HAS_IPV6*/ -# define ACE_DEFAULT_SERVER_HOST ACE_LOCALHOST -# endif /*ACE_HAS_IPV6*/ -# endif /* ACE_DEFAULT_SERVER_HOST */ - -// Default shared memory key -# if !defined (ACE_DEFAULT_SHM_KEY) -# define ACE_DEFAULT_SHM_KEY 1234 -# endif /* ACE_DEFAULT_SHM_KEY */ - -// Default address for shared memory mapped files and SYSV shared memory -// (defaults to 64 M). -# if !defined (ACE_DEFAULT_BASE_ADDR) -# define ACE_DEFAULT_BASE_ADDR ((char *) (64 * 1024 * 1024)) -# endif /* ACE_DEFAULT_BASE_ADDR */ - -// Default segment size used by SYSV shared memory (128 K) -# if !defined (ACE_DEFAULT_SEGMENT_SIZE) -# define ACE_DEFAULT_SEGMENT_SIZE 1024 * 128 -# endif /* ACE_DEFAULT_SEGMENT_SIZE */ - -// Maximum number of SYSV shared memory segments -// (does anyone know how to figure out the right values?!) -# if !defined (ACE_DEFAULT_MAX_SEGMENTS) -# define ACE_DEFAULT_MAX_SEGMENTS 6 -# endif /* ACE_DEFAULT_MAX_SEGMENTS */ - -// Name of the map that's stored in shared memory. -# if !defined (ACE_NAME_SERVER_MAP) -# define ACE_NAME_SERVER_MAP "Name Server Map" -# endif /* ACE_NAME_SERVER_MAP */ - -// Default file permissions. -# if !defined (ACE_DEFAULT_FILE_PERMS) -# if defined (ACE_VXWORKS) -# define ACE_DEFAULT_FILE_PERMS (S_IRUSR | S_IWUSR| S_IRGRP| S_IROTH) -# else -# define ACE_DEFAULT_FILE_PERMS 0644 -# endif /* ACE_VXWORKS */ -# endif /* ACE_DEFAULT_FILE_PERMS */ - -// Default directory permissions. -# if !defined (ACE_DEFAULT_DIR_PERMS) -# define ACE_DEFAULT_DIR_PERMS 0755 -# endif /* ACE_DEFAULT_DIR_PERMS */ - -# if !defined (ACE_DEFAULT_TIMEPROBE_TABLE_SIZE) -# define ACE_DEFAULT_TIMEPROBE_TABLE_SIZE 8 * 1024 -# endif /* ACE_DEFAULT_TIMEPROBE_TABLE_SIZE */ - -// Default size of the ACE Map_Manager. -# if !defined (ACE_DEFAULT_MAP_SIZE) -# define ACE_DEFAULT_MAP_SIZE 1024 -# endif /* ACE_DEFAULT_MAP_SIZE */ - -# if defined (ACE_DEFAULT_MAP_SIZE) && (ACE_DEFAULT_MAP_SIZE == 0) -# error ACE_DEFAULT_MAP_SIZE should not be zero -# endif /* ACE_DEFAULT_MAP_SIZE */ - -// Defaults for ACE Timer Wheel -# if !defined (ACE_DEFAULT_TIMER_WHEEL_SIZE) -# define ACE_DEFAULT_TIMER_WHEEL_SIZE 1024 -# endif /* ACE_DEFAULT_TIMER_WHEEL_SIZE */ - -# if !defined (ACE_DEFAULT_TIMER_WHEEL_RESOLUTION) -# define ACE_DEFAULT_TIMER_WHEEL_RESOLUTION 100 -# endif /* ACE_DEFAULT_TIMER_WHEEL_RESOLUTION */ - -// Default size for ACE Timer Hash table -# if !defined (ACE_DEFAULT_TIMER_HASH_TABLE_SIZE) -# define ACE_DEFAULT_TIMER_HASH_TABLE_SIZE 1024 -# endif /* ACE_DEFAULT_TIMER_HASH_TABLE_SIZE */ - -// Defaults for the ACE Free List -# if !defined (ACE_DEFAULT_FREE_LIST_PREALLOC) -# define ACE_DEFAULT_FREE_LIST_PREALLOC 0 -# endif /* ACE_DEFAULT_FREE_LIST_PREALLOC */ - -# if !defined (ACE_DEFAULT_FREE_LIST_LWM) -# define ACE_DEFAULT_FREE_LIST_LWM 0 -# endif /* ACE_DEFAULT_FREE_LIST_LWM */ - -# if !defined (ACE_DEFAULT_FREE_LIST_HWM) -# define ACE_DEFAULT_FREE_LIST_HWM 25000 -# endif /* ACE_DEFAULT_FREE_LIST_HWM */ - -# if !defined (ACE_DEFAULT_FREE_LIST_INC) -# define ACE_DEFAULT_FREE_LIST_INC 100 -# endif /* ACE_DEFAULT_FREE_LIST_INC */ - -# if !defined (ACE_UNIQUE_NAME_LEN) -# define ACE_UNIQUE_NAME_LEN 100 -# endif /* ACE_UNIQUE_NAME_LEN */ - -# if !defined (ACE_MAX_DGRAM_SIZE) - // This is just a guess. 8k is the normal limit on - // most machines because that's what NFS expects. -# define ACE_MAX_DGRAM_SIZE 8192 -# endif /* ACE_MAX_DGRAM_SIZE */ - -# if !defined (ACE_DEFAULT_ARGV_BUFSIZ) -# define ACE_DEFAULT_ARGV_BUFSIZ 1024 * 4 -# endif /* ACE_DEFAULT_ARGV_BUFSIZ */ - -// A free list which create more elements when there aren't enough -// elements. -# define ACE_FREE_LIST_WITH_POOL 1 - -// A simple free list which doen't allocate/deallocate elements. -# define ACE_PURE_FREE_LIST 2 - -# if defined (ACE_WIN32) - -// This is necessary to work around bugs with Win32 non-blocking -// connects... -# if !defined (ACE_NON_BLOCKING_BUG_DELAY) -# define ACE_NON_BLOCKING_BUG_DELAY 35000 -# endif /* ACE_NON_BLOCKING_BUG_DELAY */ -# endif /*ACE_WIN32*/ - -// Max size of an ACE Log Record data buffer. This can be reset in -// the config.h file if you'd like to increase or decrease the size. -# if !defined (ACE_MAXLOGMSGLEN) -# define ACE_MAXLOGMSGLEN 4 * 1024 -# endif /* ACE_MAXLOGMSGLEN */ - -// Max size of an ACE Token. -# define ACE_MAXTOKENNAMELEN 40 - -// Max size of an ACE Token client ID. -# define ACE_MAXCLIENTIDLEN MAXHOSTNAMELEN + 20 - -/// Max udp packet size -#if !defined (ACE_MAX_UDP_PACKET_SIZE) -#define ACE_MAX_UDP_PACKET_SIZE 65507 -#endif - -/** - * @name Default values to control CDR classes memory allocation strategies - */ -//@{ - -/// Control the initial size of all CDR buffers, application -/// developers may want to optimize this value to fit their request -/// size -#if !defined (ACE_DEFAULT_CDR_BUFSIZE) -# define ACE_DEFAULT_CDR_BUFSIZE 512 -#endif /* ACE_DEFAULT_CDR_BUFSIZE */ - -#if (ACE_DEFAULT_CDR_BUFSIZE == 0) -# error: ACE_DEFAULT_CDR_BUFSIZE should be bigger then 0 -#endif - -/// Stop exponential growth of CDR buffers to avoid overallocation -#if !defined (ACE_DEFAULT_CDR_EXP_GROWTH_MAX) -# define ACE_DEFAULT_CDR_EXP_GROWTH_MAX 65536 -#endif /* ACE_DEFAULT_CDR_EXP_GROWTH_MAX */ - -/// Control CDR buffer growth after maximum exponential growth is -/// reached -#if !defined (ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK) -# define ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK 65536 -#endif /* ACE_DEFAULT_CDR_LINEAR_GROWTH_CHUNK */ -//@} - -/// Control the zero-copy optimizations for octet sequences -/** - * Large octet sequences can be sent without any copies by chaining - * them in the list of message blocks that represent a single CDR - * stream. However, if the octet sequence is too small the zero copy - * optimizations actually hurt performance. Octet sequences smaller - * than this value will be copied. - */ -#if !defined (ACE_DEFAULT_CDR_MEMCPY_TRADEOFF) -#define ACE_DEFAULT_CDR_MEMCPY_TRADEOFF 256 -#endif /* ACE_DEFAULT_CDR_MEMCPY_TRADEOFF */ - -#if defined (ACE_WIN32) - // Define the pathname separator characters for Win32 (ugh). -# define ACE_DIRECTORY_SEPARATOR_STR_A "\\" -# define ACE_DIRECTORY_SEPARATOR_CHAR_A '\\' -#else - // Define the pathname separator characters for UNIX. -# define ACE_DIRECTORY_SEPARATOR_STR_A "/" -# define ACE_DIRECTORY_SEPARATOR_CHAR_A '/' -#endif /* ACE_WIN32 */ - -// Define the Wide character and normal versions of some of the string macros -#if defined (ACE_HAS_WCHAR) -# define ACE_DIRECTORY_SEPARATOR_STR_W ACE_TEXT_WIDE(ACE_DIRECTORY_SEPARATOR_STR_A) -# define ACE_DIRECTORY_SEPARATOR_CHAR_W ACE_TEXT_WIDE(ACE_DIRECTORY_SEPARATOR_CHAR_A) -#endif /* ACE_HAS_WCHAR */ - -#define ACE_DIRECTORY_SEPARATOR_STR ACE_TEXT (ACE_DIRECTORY_SEPARATOR_STR_A) -#define ACE_DIRECTORY_SEPARATOR_CHAR ACE_TEXT (ACE_DIRECTORY_SEPARATOR_CHAR_A) - -#if !defined (ACE_DEFAULT_THREAD_PRIORITY) -# define ACE_DEFAULT_THREAD_PRIORITY (-0x7fffffffL - 1L) -#endif /* ACE_DEFAULT_THREAD_PRIORITY */ - -#if !defined (ACE_DEFAULT_THREAD_STACKSIZE) -# define ACE_DEFAULT_THREAD_STACKSIZE 0 -#endif /* ACE_DEFAULT_THREAD_STACKSIZE */ - -#if !defined (ACE_MAX_DEFAULT_PORT) -# define ACE_MAX_DEFAULT_PORT 65535 -#endif /* ACE_MAX_DEFAULT_PORT */ - -// Default number of ACE_Event_Handlers supported by -// ACE_Timer_Heap. -#if !defined (ACE_DEFAULT_TIMERS) && defined (_POSIX_TIMER_MAX) -# define ACE_DEFAULT_TIMERS _POSIX_TIMER_MAX -#endif /* ACE_DEFAULT_TIMERS */ - -#if !defined (ACE_DEFAULT_TIMERS) || (defined (ACE_DEFAULT_TIMERS) && (ACE_DEFAULT_TIMERS == 0)) -#error ACE_DEFAULT_TIMERS should be defined and not be zero -#endif /* ACE_DEFAULT_TIMERS */ - -#if defined (ACE_WIN32) -# define ACE_PLATFORM_A "Win32" -# define ACE_PLATFORM_EXE_SUFFIX_A ".exe" -#elif defined (ACE_VXWORKS) -# define ACE_PLATFORM_A "VxWorks" -# if defined (__RTP__) -# define ACE_PLATFORM_EXE_SUFFIX_A ".vxe" -# else -# define ACE_PLATFORM_EXE_SUFFIX_A ".out" -# endif -#else /* !ACE_WIN32 && !ACE_VXWORKS */ -# define ACE_PLATFORM_A "UNIX" -# define ACE_PLATFORM_EXE_SUFFIX_A "" -#endif /* ACE_WIN32 */ - -// Define the Wide character and normal versions of some of the string macros -#if defined (ACE_HAS_WCHAR) -# define ACE_PLATFORM_W ACE_TEXT_WIDE(ACE_PLATFORM_A) -# define ACE_PLATFORM_EXE_SUFFIX_W ACE_TEXT_WIDE(ACE_PLATFORM_EXE_SUFFIX_A) -#endif /* ACE_HAS_WCHAR */ - -#define ACE_PLATFORM ACE_TEXT (ACE_PLATFORM_A) -#define ACE_PLATFORM_EXE_SUFFIX ACE_TEXT (ACE_PLATFORM_EXE_SUFFIX_A) - -#if defined (ACE_WIN32) -# define ACE_LD_SEARCH_PATH ACE_TEXT ("PATH") -# define ACE_LD_SEARCH_PATH_SEPARATOR_STR ACE_TEXT (";") -# define ACE_DLL_SUFFIX ACE_TEXT (".dll") -# if !defined (ACE_DLL_PREFIX) -# define ACE_DLL_PREFIX ACE_TEXT ("") -# endif /* !ACE_DLL_PREFIX */ -#else /* !ACE_WIN32 */ -# if !defined (ACE_LD_SEARCH_PATH) -# define ACE_LD_SEARCH_PATH ACE_TEXT ("LD_LIBRARY_PATH") -# endif /* ACE_LD_SEARCH_PATH */ -# if !defined (ACE_LD_SEARCH_PATH_SEPARATOR_STR) -# define ACE_LD_SEARCH_PATH_SEPARATOR_STR ACE_TEXT (":") -# endif /* ACE_LD_SEARCH_PATH_SEPARATOR_STR */ -#endif /* ACE_WIN32 */ - -#if !defined (ACE_DLL_SUFFIX) -# define ACE_DLL_SUFFIX ACE_TEXT (".so") -#endif /* ACE_DLL_SUFFIX */ - -#if !defined (ACE_DLL_PREFIX) -# define ACE_DLL_PREFIX ACE_TEXT ("lib") -#endif /* ACE_DLL_PREFIX */ - -#if defined (ACE_WIN32) -// Used for dynamic linking -# if !defined (ACE_DEFAULT_SVC_CONF) -# if (ACE_USES_CLASSIC_SVC_CONF == 1) -# define ACE_DEFAULT_SVC_CONF ACE_TEXT (".\\svc.conf") -# else -# define ACE_DEFAULT_SVC_CONF ACE_TEXT (".\\svc.conf.xml") -# endif /* ACE_USES_CLASSIC_SVC_CONF ==1 */ -# endif /* ACE_DEFAULT_SVC_CONF */ -#endif /* ACE_WIN32 */ - - // Used for dynamic linking. -#if !defined (ACE_DEFAULT_SVC_CONF) -# if (ACE_USES_CLASSIC_SVC_CONF == 1) -# define ACE_DEFAULT_SVC_CONF ACE_TEXT ("./svc.conf") -# else -# define ACE_DEFAULT_SVC_CONF ACE_TEXT ("./svc.conf.xml") -# endif /* ACE_USES_CLASSIC_SVC_CONF ==1 */ -#endif /* ACE_DEFAULT_SVC_CONF */ - -#if !defined (ACE_LOGGER_KEY) -# define ACE_LOGGER_KEY ACE_TEXT ("/tmp/server_daemon") -#endif /* ACE_LOGGER_KEY */ - -// Theses defines are used by the ACE Name Server. -#if !defined (ACE_DEFAULT_LOCALNAME_A) -# define ACE_DEFAULT_LOCALNAME_A "localnames" -#endif /* ACE_DEFAULT_LOCALNAME_A */ -#if !defined (ACE_DEFAULT_GLOBALNAME_A) -# define ACE_DEFAULT_GLOBALNAME_A "globalnames" -#endif /* ACE_DEFAULT_GLOBALNAME_A */ - -#if defined (ACE_HAS_WCHAR) -# define ACE_DEFAULT_LOCALNAME_W ACE_TEXT_WIDE(ACE_DEFAULT_LOCALNAME_A) -# define ACE_DEFAULT_GLOBALNAME_W ACE_TEXT_WIDE(ACE_DEFAULT_GLOBALNAME_A) -#endif /* ACE_HAS_WCHAR */ - -#define ACE_DEFAULT_LOCALNAME ACE_TEXT (ACE_DEFAULT_LOCALNAME_A) -#define ACE_DEFAULT_GLOBALNAME ACE_TEXT (ACE_DEFAULT_GLOBALNAME_A) - -#if !defined (ACE_DEFAULT_OPEN_PERMS) -# define ACE_DEFAULT_OPEN_PERMS ACE_DEFAULT_FILE_PERMS -#endif /* ACE_DEFAULT_OPEN_PERMS */ - -#if !defined (ACE_DEFAULT_RW_PROCESS_MUTEX_PERMS) -# if defined (ACE_WIN32) -# define ACE_DEFAULT_RW_PROCESS_MUTEX_PERMS ACE_DEFAULT_OPEN_PERMS -# else -# define ACE_DEFAULT_RW_PROCESS_MUTEX_PERMS (S_IRUSR | S_IWUSR) -# endif /* ACE_WIN32 */ -#endif /* ACE_DEFAULT_RW_PROCESS_MUTEX_PERMS */ - -# if defined (ACE_WIN32) - // The "null" device on Win32. -# define ACE_DEV_NULL "nul" -# define ACE_SYSCALL_FAILED 0xFFFFFFFF -# else /* !ACE_WIN32 */ - // The "null" device on UNIX. -# define ACE_DEV_NULL "/dev/null" -# define ACE_SYSCALL_FAILED -1 -# endif /* ACE_WIN32 */ - -#if !defined (ACE_DEFAULT_ACCEPTOR_USE_SELECT) -# define ACE_DEFAULT_ACCEPTOR_USE_SELECT 1 -#endif /* ACE_DEFAULT_ACCEPTOR_USE_SELECT */ - -#include /**/ "ace/post.h" -#endif /*ACE_DEFAULT_CONSTANTS_H*/ diff --git a/deps/acelite/ace/Dev_Poll_Reactor.cpp b/deps/acelite/ace/Dev_Poll_Reactor.cpp deleted file mode 100644 index 55cb4d4d5..000000000 --- a/deps/acelite/ace/Dev_Poll_Reactor.cpp +++ /dev/null @@ -1,2588 +0,0 @@ -#include "ace/OS_NS_errno.h" -#include "ace/Dev_Poll_Reactor.h" -#include "ace/Signal.h" -#include "ace/Sig_Handler.h" -#include "ace/Flag_Manip.h" - -#if defined (ACE_HAS_EVENT_POLL) || defined (ACE_HAS_DEV_POLL) - -# include "ace/OS_NS_unistd.h" -# include "ace/OS_NS_fcntl.h" -# include "ace/OS_NS_stropts.h" - -# if defined (ACE_HAS_DEV_POLL) -# if defined (ACE_LINUX) -# include /**/ -# elif defined (HPUX_VERS) && HPUX_VERS < 1123 -# include /**/ -# else -# include /**/ -# endif /* ACE_LINUX */ -# endif /* ACE_HAS_DEV_POLL */ - -#if !defined (__ACE_INLINE__) -# include "ace/Dev_Poll_Reactor.inl" -#endif /* __ACE_INLINE__ */ - - -#include "ace/Handle_Set.h" -#include "ace/Reactor.h" -#include "ace/Timer_Heap.h" -#include "ace/Timer_Queue.h" -#include "ace/ACE.h" -#include "ace/Reverse_Lock_T.h" -#include "ace/Recursive_Thread_Mutex.h" -#include "ace/Null_Mutex.h" -#include "ace/os_include/os_poll.h" -#include "ace/OS_NS_sys_mman.h" -#include "ace/Guard_T.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_NS_sys_time.h" -#include "ace/Functor_T.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Dev_Poll_Reactor) -ACE_ALLOC_HOOK_DEFINE(ACE_Dev_Poll_Reactor::Event_Tuple) -ACE_ALLOC_HOOK_DEFINE(ACE_Dev_Poll_Reactor_Notify) - -ACE_Dev_Poll_Reactor_Notify::ACE_Dev_Poll_Reactor_Notify (void) - : dp_reactor_ (0) - , notification_pipe_ () - , max_notify_iterations_ (-1) -#if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) - , notification_queue_ () -#endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ -{ -} - -int -ACE_Dev_Poll_Reactor_Notify::open (ACE_Reactor_Impl *r, - ACE_Timer_Queue * /* timer_queue */, - int disable_notify_pipe) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::open"); - - if (disable_notify_pipe == 0) - { - this->dp_reactor_ = dynamic_cast (r); - - if (this->dp_reactor_ == 0) - { - errno = EINVAL; - return -1; - } - - if (this->notification_pipe_.open () == -1) - return -1; - -#if defined (F_SETFD) && !defined (ACE_LACKS_FCNTL) - // close-on-exec - if (ACE_OS::fcntl (this->notification_pipe_.read_handle (), F_SETFD, 1) == -1) - { - return -1; - } - if (ACE_OS::fcntl (this->notification_pipe_.write_handle (), F_SETFD, 1) == -1) - { - return -1; - } -#endif /* F_SETFD */ - -#if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) - if (notification_queue_.open () == -1) - { - return -1; - } - - if (ACE::set_flags (this->notification_pipe_.write_handle (), - ACE_NONBLOCK) == -1) - return -1; -#endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ - - // Set the read handle into non-blocking mode since we need to - // perform a "speculative" read when determining if there are - // notifications to dispatch. - if (ACE::set_flags (this->notification_pipe_.read_handle (), - ACE_NONBLOCK) == -1) - return -1; - } - - return 0; -} - -int -ACE_Dev_Poll_Reactor_Notify::close (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::close"); - -#if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) - notification_queue_.reset (); -#endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ - - return this->notification_pipe_.close (); -} - -int -ACE_Dev_Poll_Reactor_Notify::notify (ACE_Event_Handler *eh, - ACE_Reactor_Mask mask, - ACE_Time_Value *timeout) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::notify"); - - // Just consider this method a "no-op" if there's no - // ACE_Dev_Poll_Reactor configured. - if (this->dp_reactor_ == 0) - return 0; - - ACE_Notification_Buffer buffer (eh, mask); - -#if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) - ACE_UNUSED_ARG (timeout); - ACE_Dev_Poll_Handler_Guard eh_guard (eh); - - // When using the queue, always try to write to the notify pipe. If it - // fills up, ignore it safely because the already-written bytes will - // eventually cause the notify handler to be dispatched. - if (-1 == this->notification_queue_.push_new_notification (buffer)) - return -1; // Also decrement eh's reference count - - // The notification has been queued, so it will be delivered at some - // point (and may have been already); release the refcnt guard. - eh_guard.release (); - - // Now pop the pipe to force the callback for dispatching when ready. If - // the send fails due to a full pipe, don't fail - assume the already-sent - // pipe bytes will cause the entire notification queue to be processed. - // Note that we don't need a timeout since the pipe is already in - // nonblocking mode and all we want is one attempt. - ssize_t n = ACE::send (this->notification_pipe_.write_handle (), - (char *) &buffer, - 1); // Only need one byte to pop the pipe - if (n == -1 && (errno != EAGAIN)) - return -1; - - return 0; -#else - - ACE_Dev_Poll_Handler_Guard eh_guard (eh); - - ssize_t n = ACE::send (this->notification_pipe_.write_handle (), - (char *) &buffer, - sizeof buffer, - timeout); - if (n == -1) - return -1; - - eh_guard.release (); - - return 0; -#endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ -} - -int -ACE_Dev_Poll_Reactor_Notify::dispatch_notifications ( - int & /* number_of_active_handles */, - ACE_Handle_Set & /* rd_mask */) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::dispatch_notifications"); - - // This method is unimplemented in the ACE_Dev_Poll_Reactor. - // Instead, the notification handler is invoked as part of the IO - // event set. Doing so alters the some documented semantics that - // state that the notifications are handled before IO events. - // Enforcing such semantics does not appear to be beneficial, and - // also serves to slow down event dispatching particularly with this - // ACE_Dev_Poll_Reactor. - - ACE_NOTSUP_RETURN (-1); -} - -int -ACE_Dev_Poll_Reactor_Notify::read_notify_pipe (ACE_HANDLE handle, - ACE_Notification_Buffer &buffer) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::read_notify_pipe"); - - // This is a (non-blocking) "speculative" read, i.e., we attempt to - // read even if no event was polled on the read handle. A - // speculative read is necessary since notifications must be - // dispatched before IO events. We can avoid the speculative read - // by "walking" the array of pollfd structures returned from - // `/dev/poll' or `/dev/epoll' but that is potentially much more - // expensive than simply checking for an EWOULDBLOCK. - size_t to_read; - char *read_p; - -#if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) - // The idea in the queued case is to be sure we never end up with a notify - // queued but no byte in the pipe. If that happens, the notify won't be - // dispatched. So always try to empty the pipe, read the queue, then put - // a byte in if needed. The notify() method is enqueueing then writing the - // pipe, so be sure to do it in the reverse order here to avoid a race - // between removing the last notification from the queue and the notify - // side writing its byte. - char b[1024]; - read_p = b; - to_read = sizeof(b); - (void)ACE::recv (handle, read_p, to_read); - - bool more_messages_queued = false; - ACE_Notification_Buffer next; - int result = 1; - while (result == 1) - { - result = notification_queue_.pop_next_notification (buffer, - more_messages_queued, - next); - - if (result <= 0) // Nothing dequeued or error - return result; - - // If it's just a wake-up, toss it and see if there's anything else. - if (buffer.eh_ != 0) - break; - } - - // If there are more messages, ensure there's a byte in the pipe - // in case the notification limit stops dequeuing notifies before - // emptying the queue. - if (more_messages_queued) - (void) ACE::send (this->notification_pipe_.write_handle (), - (char *)&next, - 1); /* one byte is enough */ - return 1; -#else - to_read = sizeof buffer; - read_p = (char *)&buffer; - - ssize_t n = ACE::recv (handle, read_p, to_read); - - if (n > 0) - { - // Check to see if we've got a short read. - if (static_cast (n) != to_read) - { - size_t remainder = to_read - n; - - // If so, try to recover by reading the remainder. If this - // doesn't work we're in big trouble since the input stream - // won't be aligned correctly. I'm not sure quite what to - // do at this point. It's probably best just to return -1. - if (ACE::recv (handle, &read_p[n], remainder) <= 0) - return -1; - } - - return 1; - } - - // Return -1 if things have gone seriously wrong. - if (n <= 0 && (errno != EWOULDBLOCK && errno != EAGAIN)) - return -1; - - return 0; -#endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ -} - - -int -ACE_Dev_Poll_Reactor_Notify::handle_input (ACE_HANDLE /*handle*/) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::handle_input"); - ACELIB_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("SHOULD NOT BE HERE.\n")), -1); -} - -ACE_HANDLE -ACE_Dev_Poll_Reactor_Notify::notify_handle (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::notify_handle"); - - return this->notification_pipe_.read_handle (); -} - -int -ACE_Dev_Poll_Reactor_Notify::is_dispatchable (ACE_Notification_Buffer &) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::is_dispatchable"); - - ACE_NOTSUP_RETURN (-1); -} - -int -ACE_Dev_Poll_Reactor_Notify::dispatch_notify (ACE_Notification_Buffer &buffer) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::dispatch_notify"); - - // If eh == 0 then another thread is unblocking the - // ACE_Dev_Poll_Reactor to update the ACE_Dev_Poll_Reactor's - // internal structures. Otherwise, we need to dispatch the - // appropriate handle_* method on the ACE_Event_Handler - // pointer we've been passed. - if (buffer.eh_ != 0) - { - int result = 0; - - // Guard the handler's refcount. Recall that when the notify - // was queued, the refcount was incremented, so it need not be - // now. The guard insures that it is decremented properly. - ACE_Dev_Poll_Handler_Guard eh_guard (buffer.eh_, false); - - switch (buffer.mask_) - { - case ACE_Event_Handler::READ_MASK: - case ACE_Event_Handler::ACCEPT_MASK: - result = buffer.eh_->handle_input (ACE_INVALID_HANDLE); - break; - case ACE_Event_Handler::WRITE_MASK: - result = buffer.eh_->handle_output (ACE_INVALID_HANDLE); - break; - case ACE_Event_Handler::EXCEPT_MASK: - result = buffer.eh_->handle_exception (ACE_INVALID_HANDLE); - break; - default: - // Should we bail out if we get an invalid mask? - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("dispatch_notify invalid mask = %d\n"), - buffer.mask_)); - } - if (result == -1) - buffer.eh_->handle_close (ACE_INVALID_HANDLE, buffer.mask_); - } - - return 1; -} - -void -ACE_Dev_Poll_Reactor_Notify::max_notify_iterations (int iterations) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::max_notify_iterations"); - - // Must always be > 0 or < 0 to optimize the loop exit condition. - if (iterations == 0) - iterations = 1; - - this->max_notify_iterations_ = iterations; -} - -int -ACE_Dev_Poll_Reactor_Notify::max_notify_iterations (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::max_notify_iterations"); - - return this->max_notify_iterations_; -} - -int -ACE_Dev_Poll_Reactor_Notify::purge_pending_notifications ( - ACE_Event_Handler *eh, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::purge_pending_notifications"); - -#if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) - - return notification_queue_.purge_pending_notifications (eh, mask); - -#else /* defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) */ - ACE_UNUSED_ARG (eh); - ACE_UNUSED_ARG (mask); - ACE_NOTSUP_RETURN (-1); -#endif /* defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) */ -} - -void -ACE_Dev_Poll_Reactor_Notify::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Dev_Poll_Reactor_Notify::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("dp_reactor_ = %@"), - this->dp_reactor_)); - this->notification_pipe_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -int -ACE_Dev_Poll_Reactor_Notify::dequeue_one (ACE_Notification_Buffer &nb) -{ - nb.eh_ = 0; - nb.mask_ = 0; - return this->read_notify_pipe (this->notify_handle (), nb); -} - - -// ----------------------------------------------------------------- - -ACE_Dev_Poll_Reactor::Handler_Repository::Handler_Repository (void) - : size_ (0), - max_size_ (0), - handlers_ (0) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Handler_Repository::Handler_Repository"); -} - -bool -ACE_Dev_Poll_Reactor::Handler_Repository::invalid_handle ( - ACE_HANDLE handle) const -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Handler_Repository::invalid_handle"); - - if (handle < 0 || handle >= this->max_size_) - { - errno = EINVAL; - return true; - } - else - return false; -} - -bool -ACE_Dev_Poll_Reactor::Handler_Repository::handle_in_range ( - ACE_HANDLE handle) const -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Handler_Repository::handle_in_range"); - - if (handle >= 0 && handle < this->max_size_) - return true; - else - { - errno = EINVAL; - return false; - } -} - -int -ACE_Dev_Poll_Reactor::Handler_Repository::open (size_t size) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Handler_Repository::open"); - - this->max_size_ = size; - - // Try to allocate the memory. - ACE_NEW_RETURN (this->handlers_, Event_Tuple[size], -1); - - // Try to increase the number of handles if is greater than - // the current limit. - return ACE::set_handle_limit (size); -} - -int -ACE_Dev_Poll_Reactor::Handler_Repository::unbind_all (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Handler_Repository::unbind_all"); - - // Unbind all of the event handlers; similar to remove_handler() on all. - for (int handle = 0; - handle < this->max_size_; - ++handle) - { - Event_Tuple *entry = this->find (handle); - if (entry == 0) - continue; - - // Check for ref counting now - handle_close () may delete eh. - bool const requires_reference_counting = - entry->event_handler->reference_counting_policy ().value () == - ACE_Event_Handler::Reference_Counting_Policy::ENABLED; - - (void) entry->event_handler->handle_close (handle, entry->mask); - this->unbind (handle, requires_reference_counting); - } - - return 0; -} - -int -ACE_Dev_Poll_Reactor::Handler_Repository::close (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Handler_Repository::close"); - - if (this->handlers_ != 0) - { - this->unbind_all (); - - delete [] this->handlers_; - this->handlers_ = 0; - } - - return 0; -} - -ACE_Dev_Poll_Reactor::Event_Tuple * -ACE_Dev_Poll_Reactor::Handler_Repository::find (ACE_HANDLE handle) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Handler_Repository::find"); - - Event_Tuple *tuple = 0; - - // Only bother to search for the if it's in range. - if (!this->handle_in_range (handle)) - { - errno = ERANGE; - return 0; - } - - tuple = &(this->handlers_[handle]); - if (tuple->event_handler == 0) - { - errno = ENOENT; - tuple = 0; - } - - return tuple; -} - -int -ACE_Dev_Poll_Reactor::Handler_Repository::bind ( - ACE_HANDLE handle, - ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Handler_Repository::bind"); - - if (event_handler == 0) - return -1; - - if (handle == ACE_INVALID_HANDLE) - handle = event_handler->get_handle (); - - if (this->invalid_handle (handle)) - return -1; - - this->handlers_[handle].event_handler = event_handler; - this->handlers_[handle].mask = mask; - event_handler->add_reference (); - ++this->size_; - - return 0; -} - -int -ACE_Dev_Poll_Reactor::Handler_Repository::unbind (ACE_HANDLE handle, - bool decr_refcnt) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Handler_Repository::unbind"); - - Event_Tuple *entry = this->find (handle); - if (entry == 0) - return -1; - - if (decr_refcnt) - entry->event_handler->remove_reference (); - - entry->event_handler = 0; - entry->mask = ACE_Event_Handler::NULL_MASK; - entry->suspended = false; - entry->controlled = false; - --this->size_; - return 0; -} - -// ----------------------------------------------------------------- - -ACE_Dev_Poll_Reactor::ACE_Dev_Poll_Reactor (ACE_Sig_Handler *sh, - ACE_Timer_Queue *tq, - int disable_notify_pipe, - ACE_Reactor_Notify *notify, - int mask_signals, - int s_queue) - : initialized_ (false) - , poll_fd_ (ACE_INVALID_HANDLE) - // , ready_set_ () -#if defined (ACE_HAS_DEV_POLL) - , dp_fds_ (0) - , start_pfds_ (0) - , end_pfds_ (0) -#endif /* ACE_HAS_DEV_POLL */ - , token_ (*this, s_queue) - , lock_adapter_ (token_) - , deactivated_ (0) - , timer_queue_ (0) - , delete_timer_queue_ (false) - , signal_handler_ (0) - , delete_signal_handler_ (false) - , notify_handler_ (0) - , delete_notify_handler_ (false) - , mask_signals_ (mask_signals) - , restart_ (0) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::ACE_Dev_Poll_Reactor"); - - if (this->open (ACE::max_handles (), - 0, - sh, - tq, - disable_notify_pipe, - notify) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Dev_Poll_Reactor::open ") - ACE_TEXT ("failed inside ") - ACE_TEXT ("ACE_Dev_Poll_Reactor::CTOR"))); -} - -ACE_Dev_Poll_Reactor::ACE_Dev_Poll_Reactor (size_t size, - bool rs, - ACE_Sig_Handler *sh, - ACE_Timer_Queue *tq, - int disable_notify_pipe, - ACE_Reactor_Notify *notify, - int mask_signals, - int s_queue) - : initialized_ (false) - , poll_fd_ (ACE_INVALID_HANDLE) - // , ready_set_ () -#if defined (ACE_HAS_DEV_POLL) - , dp_fds_ (0) - , start_pfds_ (0) - , end_pfds_ (0) -#endif /* ACE_HAS_DEV_POLL */ - , token_ (*this, s_queue) - , lock_adapter_ (token_) - , deactivated_ (0) - , timer_queue_ (0) - , delete_timer_queue_ (false) - , signal_handler_ (0) - , delete_signal_handler_ (false) - , notify_handler_ (0) - , delete_notify_handler_ (false) - , mask_signals_ (mask_signals) - , restart_ (0) -{ - if (this->open (size, - rs, - sh, - tq, - disable_notify_pipe, - notify) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Dev_Poll_Reactor::open ") - ACE_TEXT ("failed inside ACE_Dev_Poll_Reactor::CTOR"))); -} - -ACE_Dev_Poll_Reactor::~ACE_Dev_Poll_Reactor (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::~ACE_Dev_Poll_Reactor"); - - (void) this->close (); -} - -int -ACE_Dev_Poll_Reactor::open (size_t size, - bool restart, - ACE_Sig_Handler *sh, - ACE_Timer_Queue *tq, - int disable_notify_pipe, - ACE_Reactor_Notify *notify) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::open"); - - ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); - - // Can't initialize ourselves more than once. - if (this->initialized_) - return -1; - -#ifdef ACE_HAS_EVENT_POLL - ACE_OS::memset (&this->event_, 0, sizeof (this->event_)); - this->event_.data.fd = ACE_INVALID_HANDLE; -#endif /* ACE_HAS_EVENT_POLL */ - - this->restart_ = restart; - this->signal_handler_ = sh; - this->timer_queue_ = tq; - this->notify_handler_ = notify; - - int result = 0; - - // Allows the signal handler to be overridden. - if (this->signal_handler_ == 0) - { - ACE_NEW_RETURN (this->signal_handler_, - ACE_Sig_Handler, - -1); - - if (this->signal_handler_ == 0) - result = -1; - else - this->delete_signal_handler_ = true; - } - - // Allows the timer queue to be overridden. - if (result != -1 && this->timer_queue_ == 0) - { - ACE_NEW_RETURN (this->timer_queue_, - ACE_Timer_Heap, - -1); - - if (this->timer_queue_ == 0) - result = -1; - else - this->delete_timer_queue_ = true; - } - - // Allows the Notify_Handler to be overridden. - if (result != -1 && this->notify_handler_ == 0) - { - ACE_NEW_RETURN (this->notify_handler_, - ACE_Dev_Poll_Reactor_Notify, - -1); - - if (this->notify_handler_ == 0) - result = -1; - else - this->delete_notify_handler_ = true; - } - -#if defined (ACE_HAS_EVENT_POLL) - - // Initialize epoll: - this->poll_fd_ = ::epoll_create (size); - if (this->poll_fd_ == -1) - result = -1; - -#else - - // Allocate the array before opening the device to avoid a potential - // resource leak if allocation fails. - ACE_NEW_RETURN (this->dp_fds_, - pollfd[size], - -1); - - // Open the `/dev/poll' character device. - this->poll_fd_ = ACE_OS::open ("/dev/poll", O_RDWR); - if (this->poll_fd_ == ACE_INVALID_HANDLE) - result = -1; - -#endif /* ACE_HAS_EVENT_POLL */ - - if (result != -1 && this->handler_rep_.open (size) == -1) - result = -1; - - // Registration of the notification handler must be done after the - // /dev/poll device has been fully initialized. - else if (this->notify_handler_->open (this, - 0, - disable_notify_pipe) == -1 - || (disable_notify_pipe == 0 - && this->register_handler_i ( - this->notify_handler_->notify_handle (), - this->notify_handler_, - ACE_Event_Handler::READ_MASK) == -1)) - result = -1; - - if (result != -1) - // We're all set to go. - this->initialized_ = true; - else - // This will close down all the allocated resources properly. - (void) this->close (); - - return result; -} - -int -ACE_Dev_Poll_Reactor::current_info (ACE_HANDLE, size_t & /* size */) -{ - ACE_NOTSUP_RETURN (-1); -} - - -int -ACE_Dev_Poll_Reactor::set_sig_handler (ACE_Sig_Handler *signal_handler) -{ - if (this->delete_signal_handler_) - delete this->signal_handler_; - - this->signal_handler_ = signal_handler; - this->delete_signal_handler_ = false; - - return 0; -} - -int -ACE_Dev_Poll_Reactor::timer_queue (ACE_Timer_Queue *tq) -{ - if (this->delete_timer_queue_) - delete this->timer_queue_; - else if (this->timer_queue_) - this->timer_queue_->close (); - - this->timer_queue_ = tq; - this->delete_timer_queue_ = false; - - return 0; -} - -ACE_Timer_Queue * -ACE_Dev_Poll_Reactor::timer_queue (void) const -{ - return this->timer_queue_; -} - -int -ACE_Dev_Poll_Reactor::close (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::close"); - - ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); - - int result = 0; - - if (this->poll_fd_ != ACE_INVALID_HANDLE) - { - result = ACE_OS::close (this->poll_fd_); - } - -#if defined (ACE_HAS_EVENT_POLL) - - ACE_OS::memset (&this->event_, 0, sizeof (this->event_)); - this->event_.data.fd = ACE_INVALID_HANDLE; - -#else - - delete [] this->dp_fds_; - this->dp_fds_ = 0; - this->start_pfds_ = 0; - this->end_pfds_ = 0; - -#endif /* ACE_HAS_EVENT_POLL */ - - if (this->delete_signal_handler_) - { - delete this->signal_handler_; - this->signal_handler_ = 0; - this->delete_signal_handler_ = false; - } - - (void) this->handler_rep_.close (); - - if (this->delete_timer_queue_) - { - delete this->timer_queue_; - this->timer_queue_ = 0; - this->delete_timer_queue_ = false; - } - else if (this->timer_queue_) - { - this->timer_queue_->close (); - this->timer_queue_ = 0; - } - - if (this->notify_handler_ != 0) - this->notify_handler_->close (); - - if (this->delete_notify_handler_) - { - delete this->notify_handler_; - this->notify_handler_ = 0; - this->delete_notify_handler_ = false; - } - - this->poll_fd_ = ACE_INVALID_HANDLE; - - this->initialized_ = false; - - return result; -} - -int -ACE_Dev_Poll_Reactor::work_pending (const ACE_Time_Value & max_wait_time) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::work_pending"); - - // Stash the current time - // - // The destructor of this object will automatically compute how much - // time elapsed since this method was called. - ACE_Time_Value mwt (max_wait_time); - ACE_MT (ACE_Countdown_Time countdown (&mwt)); - - Token_Guard guard (this->token_); - int const result = guard.acquire_quietly (&mwt); - - // If the guard is NOT the owner just return the retval - if (!guard.is_owner ()) - return result; - - // Update the countdown to reflect time waiting for the mutex. - ACE_MT (countdown.update ()); - - return this->work_pending_i (&mwt); -} - -int -ACE_Dev_Poll_Reactor::work_pending_i (ACE_Time_Value * max_wait_time) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::work_pending_i"); - - if (this->deactivated_) - return 0; - -#if defined (ACE_HAS_EVENT_POLL) - if (this->event_.data.fd != ACE_INVALID_HANDLE) -#else - if (this->start_pfds_ != this->end_pfds_) -#endif /* ACE_HAS_EVENT_POLL */ - return 1; // We still have work_pending (). Do not poll for - // additional events. - - ACE_Time_Value timer_buf (0); - ACE_Time_Value *this_timeout = - this->timer_queue_->calculate_timeout (max_wait_time, &timer_buf); - - // Check if we have timers to fire. - int const timers_pending = - ((this_timeout != 0 && max_wait_time == 0) - || (this_timeout != 0 && max_wait_time != 0 - && *this_timeout != *max_wait_time) ? 1 : 0); - - long const timeout = - (this_timeout == 0 - ? -1 /* Infinity */ - : static_cast (this_timeout->msec ())); - -#if defined (ACE_HAS_EVENT_POLL) - - // Wait for an event. - int const nfds = ::epoll_wait (this->poll_fd_, - &this->event_, - 1, - static_cast (timeout)); - -#else - - struct dvpoll dvp; - - dvp.dp_fds = this->dp_fds_; - dvp.dp_nfds = this->handler_rep_.size (); - dvp.dp_timeout = timeout; // Milliseconds - - // Poll for events - int const nfds = ACE_OS::ioctl (this->poll_fd_, DP_POLL, &dvp); - - // Retrieve the results from the pollfd array. - this->start_pfds_ = dvp.dp_fds; - - // If nfds == 0 then end_pfds_ == start_pfds_ meaning that there is - // no work pending. If nfds > 0 then there is work pending. - // Otherwise an error occurred. - if (nfds > -1) - this->end_pfds_ = this->start_pfds_ + nfds; -#endif /* ACE_HAS_EVENT_POLL */ - - // If timers are pending, override any timeout from the poll. - return (nfds == 0 && timers_pending != 0 ? 1 : nfds); -} - - -int -ACE_Dev_Poll_Reactor::handle_events (ACE_Time_Value *max_wait_time) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::handle_events"); - - // Stash the current time - // - // The destructor of this object will automatically compute how much - // time elapsed since this method was called. - ACE_Countdown_Time countdown (max_wait_time); - - Token_Guard guard (this->token_); - int const result = guard.acquire_quietly (max_wait_time); - - // If the guard is NOT the owner just return the retval - if (!guard.is_owner ()) - return result; - - if (this->deactivated_) - { - errno = ESHUTDOWN; - return -1; - } - - // Update the countdown to reflect time waiting for the mutex. - ACE_MT (countdown.update ()); - - return this->handle_events_i (max_wait_time, guard); -} - -int -ACE_Dev_Poll_Reactor::handle_events_i (ACE_Time_Value *max_wait_time, - Token_Guard &guard) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::handle_events_i"); - - int result = 0; - - // Poll for events - // - // If the underlying event wait call was interrupted via the interrupt - // signal (i.e. returned -1 with errno == EINTR) then the loop will - // be restarted if so desired. - do - { - result = this->work_pending_i (max_wait_time); - if (result == -1 && (this->restart_ == 0 || errno != EINTR)) - ACELIB_ERROR ((LM_ERROR, ACE_TEXT("%t: %p\n"), ACE_TEXT("work_pending_i"))); - } - while (result == -1 && this->restart_ != 0 && errno == EINTR); - - if (result == 0 || (result == -1 && errno == ETIME)) - return 0; - else if (result == -1) - { - if (errno != EINTR) - return -1; - - // Bail out -- we got here since the poll was interrupted. - // If it was due to a signal registered through our ACE_Sig_Handler, - // then it was dispatched, so we count it in the number of events - // handled rather than cause an error return. - if (ACE_Sig_Handler::sig_pending () != 0) - { - ACE_Sig_Handler::sig_pending (0); - return 1; - } - return -1; - } - - // Dispatch an event. - return this->dispatch (guard); -} - -// Dispatch an event. On entry, the token is held by the caller. If an -// event is found to dispatch, the token is released before dispatching it. -int -ACE_Dev_Poll_Reactor::dispatch (Token_Guard &guard) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::dispatch"); - - // Perform the Template Method for dispatching the first located event. - // We dispatch only one to effectively dispatch events concurrently. - // As soon as an event is located, the token is released, allowing the - // next waiter to begin getting an event while we dispatch one here. - int result = 0; - - // Handle timers early since they may have higher latency - // constraints than I/O handlers. Ideally, the order of - // dispatching should be a strategy... - if ((result = this->dispatch_timer_handler (guard)) != 0) - return result; - - // If no timer dispatched, check for an I/O event. - result = this->dispatch_io_event (guard); - - return result; -} - -int -ACE_Dev_Poll_Reactor::dispatch_timer_handler (Token_Guard &guard) -{ - typedef ACE_Member_Function_Command Guard_Release; - - Guard_Release release(guard, &Token_Guard::release_token); - return this->timer_queue_->expire_single(release); -} - -#if 0 -int -ACE_Dev_Poll_Reactor::dispatch_notification_handlers ( - ACE_Select_Reactor_Handle_Set &dispatch_set, - int &number_of_active_handles, - int &number_of_handlers_dispatched) -{ - // Check to see if the ACE_HANDLE associated with the - // Dev_Poll_Reactor's notify hook is enabled. If so, it means that - // one or more other threads are trying to update the - // ACE_Dev_Poll_Reactor's internal tables or the notify pipe is - // enabled. We'll handle all these threads and notifications, and - // then break out to continue the event loop. - - const int n = - this->notify_handler_->dispatch_notifications (number_of_active_handles, - dispatch_set.rd_mask_); - - if (n == -1) - return -1; - else - number_of_handlers_dispatched += n; - - return /* this->state_changed_ ? -1 : */ 0; -} -#endif /* 0 */ - -int -ACE_Dev_Poll_Reactor::dispatch_io_event (Token_Guard &guard) -{ - - // Dispatch a ready event. - - // Define bits to check for while dispatching. -#if defined (ACE_HAS_EVENT_POLL) - const __uint32_t out_event = EPOLLOUT; - const __uint32_t exc_event = EPOLLPRI; - const __uint32_t in_event = EPOLLIN; - const __uint32_t err_event = EPOLLHUP | EPOLLERR; -#else - const short out_event = POLLOUT; - const short exc_event = POLLPRI; - const short in_event = POLLIN; - const short err_event = 0; // No known bits for this -#endif /* ACE_HAS_EVENT_POLL */ - -#if defined (ACE_HAS_EVENT_POLL) - // epoll_wait() pulls one event which is stored in event_. If the handle - // is invalid, there's no event there. Else process it. In any event, we - // have the event, so clear event_ for the next thread. - const ACE_HANDLE handle = this->event_.data.fd; - __uint32_t revents = this->event_.events; - this->event_.data.fd = ACE_INVALID_HANDLE; - this->event_.events = 0; - if (handle != ACE_INVALID_HANDLE) - -#else - // Since the underlying event demultiplexing mechansim (`/dev/poll' - // or '/dev/epoll') is stateful, and since only one result buffer is - // used, all pending events (i.e. those retrieved from a previous - // poll) must be dispatched before any additional event can be - // polled. As such, the Dev_Poll_Reactor keeps track of the - // progress of events that have been dispatched. - - // Select the first available handle with event (s) pending. Check for - // event type in defined order of dispatch: output, exception, input. - // When an event is located, clear its bit in the dispatch set. If there - // are no more events for the handle, also increment the pfds pointer - // to move to the next handle ready. - // - // Notice that pfds only contains file descriptors that have - // received events. - struct pollfd *& pfds = this->start_pfds_; - const ACE_HANDLE handle = pfds->fd; - short &revents = pfds->revents; - if (pfds < this->end_pfds_) -#endif /* ACE_HAS_EVENT_POLL */ - - { - /* When using sys_epoll, we can attach arbitrary user - data to the descriptor, so it can be delivered when - activity is detected. Perhaps we should store event - handler together with descriptor, instead of looking - it up in a repository ? Could it boost performance ? - */ - - // Going to access handler repo, so lock it. If the lock is - // unobtainable, something is very wrong so bail out. - Event_Tuple *info = 0; - ACE_Reactor_Mask disp_mask = 0; - ACE_Event_Handler *eh = 0; - int (ACE_Event_Handler::*callback)(ACE_HANDLE) = 0; - bool reactor_resumes_eh = false; - { - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1); - info = this->handler_rep_.find (handle); - if (info == 0) // No registered handler any longer - return 0; - - // It is possible another thread has changed (and possibly re-armed) - // this handle mask before current thread obtained the repo lock. - // If that did happen and this handler is still suspended, don't - // dispatch on top of another callback. See Bugzilla 4129. - if (info->suspended) - return 0; - - // Figure out what to do first in order to make it easier to manage - // the bit twiddling and possible pfds increment before releasing - // the token for dispatch. - // Note that if there's an error (such as the handle was closed - // without being removed from the event set) the EPOLLHUP and/or - // EPOLLERR bits will be set in revents. - eh = info->event_handler; - if (ACE_BIT_ENABLED (revents, out_event)) - { - disp_mask = ACE_Event_Handler::WRITE_MASK; - callback = &ACE_Event_Handler::handle_output; - ACE_CLR_BITS (revents, out_event); - } - else if (ACE_BIT_ENABLED (revents, exc_event)) - { - disp_mask = ACE_Event_Handler::EXCEPT_MASK; - callback = &ACE_Event_Handler::handle_exception; - ACE_CLR_BITS (revents, exc_event); - } - else if (ACE_BIT_ENABLED (revents, in_event)) - { - disp_mask = ACE_Event_Handler::READ_MASK; - callback = &ACE_Event_Handler::handle_input; - ACE_CLR_BITS (revents, in_event); - } - else if (ACE_BIT_ENABLED (revents, err_event)) - { - this->remove_handler_i (handle, - ACE_Event_Handler::ALL_EVENTS_MASK, - grd, - info->event_handler); -#ifdef ACE_HAS_DEV_POLL - ++pfds; -#endif /* ACE_HAS_DEV_POLL */ - return 1; - } - else - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("(%t) dispatch_io h %d unknown events 0x%x\n"), - handle, revents)); - } - -#ifdef ACE_HAS_DEV_POLL - // Increment the pointer to the next element before we - // release the token. Otherwise event handlers end up being - // dispatched multiple times for the same poll. - if (revents == 0) - ++pfds; -#else - // With epoll, events are registered with oneshot, so the handle is - // effectively suspended; future calls to epoll_wait() will select - // the next event, so they're not managed here. - // The hitch to this is that the notify handler is always registered - // WITHOUT oneshot and is never suspended/resumed. This avoids endless - // notify loops caused by the notify handler requiring a resumption - // which requires the token, which requires a notify, etc. described - // in Bugzilla 3714. So, never suspend the notify handler. - if (eh != this->notify_handler_) - { - info->suspended = true; - - reactor_resumes_eh = - eh->resume_handler () == - ACE_Event_Handler::ACE_REACTOR_RESUMES_HANDLER; - } -#endif /* ACE_HAS_DEV_POLL */ - - } // End scope for ACE_GUARD holding repo lock - - int status = 0; // gets callback status, below. - - // Dispatch notifies directly. The notify dispatcher locates a - // notification then releases the token prior to dispatching it. - // NOTE: If notify_handler_->dispatch_one() returns a fail condition - // it has not releases the guard. Else, it has. - if (eh == this->notify_handler_) - { - ACE_Notification_Buffer b; - status = - dynamic_cast(notify_handler_)->dequeue_one (b); - if (status == -1) - return status; - guard.release_token (); - return notify_handler_->dispatch_notify (b); - } - - { - // Modify the reference count in an exception-safe way. - // Note that eh could be the notify handler. It's not strictly - // necessary to manage its refcount, but since we don't enable - // the counting policy, it won't do much. Management of the - // notified handlers themselves is done in the notify handler. - ACE_Dev_Poll_Handler_Guard eh_guard (eh); - - // Release the reactor token before upcall. - guard.release_token (); - - // Dispatch the detected event; will do the repeated upcalls - // if callback returns > 0, unless it's the notify handler (which - // returns the number of notfies dispatched, not an indication of - // re-callback requested). If anything other than the notify, come - // back with either 0 or < 0. - status = this->upcall (eh, callback, handle); - - // If the callback returned 0, epoll-based needs to resume the - // suspended handler but dev/poll doesn't. - // In both epoll and dev/poll cases, if the callback returns <0, - // the token needs to be acquired and the handler checked and - // removed if it hasn't already been. - if (status == 0) - { -#ifdef ACE_HAS_EVENT_POLL - // epoll-based effectively suspends handlers around the upcall. - // If the handler must be resumed, check to be sure it's the - // same handle/handler combination still. - if (reactor_resumes_eh) - { - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1); - info = this->handler_rep_.find (handle); - if (info != 0 && info->event_handler == eh) - this->resume_handler_i (handle); - } -#endif /* ACE_HAS_EVENT_POLL */ - return 1; - } - - // All state in the handler repository may have changed during the - // upcall. Thus, reacquire the repo lock and evaluate what's needed. - // If the upcalled handler is still the handler of record for handle, - // continue with checking whether or not to remove or resume the - // handler. - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, 1); - info = this->handler_rep_.find (handle); - if (info != 0 && info->event_handler == eh) - { - if (status < 0) - { - this->remove_handler_i (handle, disp_mask, grd); -#ifdef ACE_HAS_EVENT_POLL - // epoll-based effectively suspends handlers around the upcall. - // If the handler must be resumed, check to be sure it's the - // same handle/handler combination still. - if (reactor_resumes_eh) - { - info = this->handler_rep_.find (handle); - if (info != 0 && info->event_handler == eh) - { - this->resume_handler_i (handle); - } - } -#endif /* ACE_HAS_EVENT_POLL */ - } - } - } - // Scope close handles eh ref count decrement, if needed. - - return 1; - } - - return 0; -} - -int -ACE_Dev_Poll_Reactor::alertable_handle_events (ACE_Time_Value *max_wait_time) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::alertable_handle_events"); - - return this->handle_events (max_wait_time); -} - -int -ACE_Dev_Poll_Reactor::handle_events (ACE_Time_Value &max_wait_time) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::handle_events"); - - return this->handle_events (&max_wait_time); -} - -int -ACE_Dev_Poll_Reactor::alertable_handle_events (ACE_Time_Value &max_wait_time) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::alertable_handle_events"); - - return this->handle_events (max_wait_time); -} - -int -ACE_Dev_Poll_Reactor::deactivated (void) -{ - return this->deactivated_; -} - -void -ACE_Dev_Poll_Reactor::deactivate (int do_stop) -{ - this->deactivated_ = do_stop; - this->wakeup_all_threads (); -} - -int -ACE_Dev_Poll_Reactor::register_handler (ACE_Event_Handler *handler, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::register_handler"); - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - return this->register_handler_i (handler->get_handle (), - handler, - mask); -} - -int -ACE_Dev_Poll_Reactor::register_handler (ACE_HANDLE handle, - ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::register_handler"); - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - return this->register_handler_i (handle, - event_handler, - mask); -} - -int -ACE_Dev_Poll_Reactor::register_handler_i (ACE_HANDLE handle, - ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::register_handler_i"); - - if (handle == ACE_INVALID_HANDLE - || mask == ACE_Event_Handler::NULL_MASK) - { - errno = EINVAL; - return -1; - } - - if (this->handler_rep_.find (handle) == 0) - { - // Handler not present in the repository. Bind it. - if (this->handler_rep_.bind (handle, event_handler, mask) != 0) - return -1; - -#if defined (ACE_HAS_EVENT_POLL) - - Event_Tuple *info = this->handler_rep_.find (handle); - - struct epoll_event epev; - ACE_OS::memset (&epev, 0, sizeof (epev)); - static const int op = EPOLL_CTL_ADD; - - epev.data.fd = handle; - epev.events = this->reactor_mask_to_poll_event (mask); - // All but the notify handler get registered with oneshot to facilitate - // auto suspend before the upcall. See dispatch_io_event for more - // information. - if (event_handler != this->notify_handler_) - epev.events |= EPOLLONESHOT; - - if (::epoll_ctl (this->poll_fd_, op, handle, &epev) == -1) - { - ACELIB_ERROR ((LM_ERROR, ACE_TEXT("%p\n"), ACE_TEXT("epoll_ctl"))); - (void) this->handler_rep_.unbind (handle); - return -1; - } - info->controlled = true; - -#endif /* ACE_HAS_EVENT_POLL */ - } - else - { - // Handler is already present in the repository, so register it - // again, possibly for different event. Add new mask to the - // current one. - if (this->mask_ops_i (handle, mask, ACE_Reactor::ADD_MASK) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, ACE_TEXT("%p\n"), ACE_TEXT("mask_ops_i")), - -1); - } - -#ifdef ACE_HAS_DEV_POLL - - struct pollfd pfd; - - pfd.fd = handle; - pfd.events = this->reactor_mask_to_poll_event (mask); - pfd.revents = 0; - - // Add file descriptor to the "interest set." - if (ACE_OS::write (this->poll_fd_, &pfd, sizeof (pfd)) != sizeof (pfd)) - { - (void) this->handler_rep_.unbind (handle); - return -1; - } -#endif /*ACE_HAS_DEV_POLL*/ - - // Note the fact that we've changed the state of the wait_set_, - // which is used by the dispatching loop to determine whether it can - // keep going or if it needs to reconsult select (). - // this->state_changed_ = 1; - - return 0; -} - -int -ACE_Dev_Poll_Reactor::register_handler ( - ACE_HANDLE /* event_handle */, - ACE_HANDLE /* io_handle */, - ACE_Event_Handler * /* event_handler */, - ACE_Reactor_Mask /* mask */) -{ - ACE_NOTSUP_RETURN (-1); -} - -int -ACE_Dev_Poll_Reactor::register_handler (const ACE_Handle_Set &handle_set, - ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::register_handler"); - - ACE_Handle_Set_Iterator handle_iter (handle_set); - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - // @@ It might be more efficient to construct a pollfd array and - // pass it to the write () call in register_handler_i () only once, - // instead of calling write () (a system call) once for each file - // descriptor. - - for (ACE_HANDLE h = handle_iter (); - h != ACE_INVALID_HANDLE; - h = handle_iter ()) - if (this->register_handler_i (h, event_handler, mask) == -1) - return -1; - - return 0; -} - -int -ACE_Dev_Poll_Reactor::register_handler (int signum, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp, - ACE_Event_Handler **old_sh, - ACE_Sig_Action *old_disp) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::register_handler"); - - return this->signal_handler_->register_handler (signum, - new_sh, - new_disp, - old_sh, - old_disp); -} - -int -ACE_Dev_Poll_Reactor::register_handler (const ACE_Sig_Set &sigset, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::register_handler"); - - int result = 0; - -#if (ACE_NSIG > 0) - - for (int s = 1; s < ACE_NSIG; ++s) - if ((sigset.is_member (s) == 1) - && this->signal_handler_->register_handler (s, - new_sh, - new_disp) == -1) - result = -1; - -#else /* ACE_NSIG <= 0 */ - - ACE_UNUSED_ARG (sigset); - ACE_UNUSED_ARG (new_sh); - ACE_UNUSED_ARG (new_disp); - -#endif /* ACE_NSIG <= 0 */ - - return result; -} - -int -ACE_Dev_Poll_Reactor::remove_handler (ACE_Event_Handler *handler, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::remove_handler"); - - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1); - return this->remove_handler_i (handler->get_handle (), mask, grd); -} - -int -ACE_Dev_Poll_Reactor::remove_handler (ACE_HANDLE handle, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::remove_handler"); - - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1); - - return this->remove_handler_i (handle, mask, grd); -} - -// FUZZ: disable check_for_ACE_Guard -int -ACE_Dev_Poll_Reactor::remove_handler_i (ACE_HANDLE handle, - ACE_Reactor_Mask mask, - ACE_Guard &repo_guard, - ACE_Event_Handler *eh) -// FUZZ: enable check_for_ACE_Guard -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::remove_handler_i"); - - // If registered event handler not the same as eh, don't mess with - // the mask, but do the proper callback and refcount when needed. - bool handle_reg_changed = true; - Event_Tuple *info = this->handler_rep_.find (handle); - if (info == 0 && eh == 0) // Nothing to work with - return -1; - if (info != 0 && (eh == 0 || info->event_handler == eh)) - { - if (this->mask_ops_i (handle, mask, ACE_Reactor::CLR_MASK) == -1) - return -1; - handle_reg_changed = false; - eh = info->event_handler; - } - - // Check for ref counting now - handle_close () may delete eh. - bool const requires_reference_counting = - eh->reference_counting_policy ().value () == - ACE_Event_Handler::Reference_Counting_Policy::ENABLED; - - if (ACE_BIT_DISABLED (mask, ACE_Event_Handler::DONT_CALL)) - { - // It would be great if ACE_Reverse_Lock worked with the Guard. - repo_guard.release (); - eh->handle_close (handle, mask); - repo_guard.acquire (); - } - - // If there are no longer any outstanding events on the given handle - // then remove it from the handler repository. - if (!handle_reg_changed && info->mask == ACE_Event_Handler::NULL_MASK) - this->handler_rep_.unbind (handle, requires_reference_counting); - - return 0; -} - -int -ACE_Dev_Poll_Reactor::remove_handler (const ACE_Handle_Set &handle_set, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::remove_handler"); - - ACE_Handle_Set_Iterator handle_iter (handle_set); - for (ACE_HANDLE h = handle_iter (); - h != ACE_INVALID_HANDLE; - h = handle_iter ()) - { - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1); - if (this->remove_handler_i (h, mask, grd) == -1) - return -1; - } - return 0; -} - -int -ACE_Dev_Poll_Reactor::remove_handler (int signum, - ACE_Sig_Action *new_disp, - ACE_Sig_Action *old_disp, - int sigkey) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::remove_handler"); - - return this->signal_handler_->remove_handler (signum, - new_disp, - old_disp, - sigkey); -} - -int -ACE_Dev_Poll_Reactor::remove_handler (const ACE_Sig_Set &sigset) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::remove_handler"); - - int result = 0; - -#if (ACE_NSIG > 0) - - for (int s = 1; s < ACE_NSIG; ++s) - if ((sigset.is_member (s) == 1) - && this->signal_handler_->remove_handler (s) == -1) - result = -1; - -#else /* ACE_NSIG <= 0 */ - - ACE_UNUSED_ARG (sigset); - -#endif /* ACE_NSIG <= 0 */ - - return result; -} - -int -ACE_Dev_Poll_Reactor::suspend_handler (ACE_Event_Handler *event_handler) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::suspend_handler"); - - if (event_handler == 0) - { - errno = EINVAL; - return -1; - } - - ACE_HANDLE handle = event_handler->get_handle (); - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - return this->suspend_handler_i (handle); -} - -int -ACE_Dev_Poll_Reactor::suspend_handler (ACE_HANDLE handle) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::suspend_handler"); - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - return this->suspend_handler_i (handle); -} - -int -ACE_Dev_Poll_Reactor::suspend_handler (const ACE_Handle_Set &handles) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::suspend_handler"); - - ACE_Handle_Set_Iterator handle_iter (handles); - ACE_HANDLE h; - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - while ((h = handle_iter ()) != ACE_INVALID_HANDLE) - if (this->suspend_handler_i (h) == -1) - return -1; - - return 0; -} - -int -ACE_Dev_Poll_Reactor::suspend_handlers (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::suspend_handlers"); - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - size_t const len = this->handler_rep_.max_size (); - - for (size_t i = 0; i < len; ++i) - { - Event_Tuple *info = this->handler_rep_.find (i); - if (info != 0 && !info->suspended && this->suspend_handler_i (i) != 0) - return -1; - } - return 0; -} - -int -ACE_Dev_Poll_Reactor::suspend_handler_i (ACE_HANDLE handle) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::suspend_handler_i"); - - Event_Tuple *info = this->handler_rep_.find (handle); - if (info == 0) - return -1; - - if (info->suspended) - return 0; // Already suspended. @@ Should this be an error? - - // Remove the handle from the "interest set." - // - // Note that the associated event handler is still in the handler - // repository, but no events will be polled on the given handle thus - // no event will be dispatched to the event handler. - -#if defined (ACE_HAS_EVENT_POLL) - - struct epoll_event epev; - ACE_OS::memset (&epev, 0, sizeof (epev)); - static const int op = EPOLL_CTL_DEL; - - epev.events = 0; - epev.data.fd = handle; - - if (::epoll_ctl (this->poll_fd_, op, handle, &epev) == -1) - return -1; - info->controlled = false; -#else - - struct pollfd pfd[1]; - - pfd[0].fd = handle; - pfd[0].events = POLLREMOVE; - pfd[0].revents = 0; - - if (ACE_OS::write (this->poll_fd_, pfd, sizeof (pfd)) != sizeof (pfd)) - return -1; - -#endif /* ACE_HAS_EVENT_POLL */ - - info->suspended = true; - - return 0; -} - -int -ACE_Dev_Poll_Reactor::resume_handler (ACE_Event_Handler *event_handler) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::resume_handler"); - - if (event_handler == 0) - { - errno = EINVAL; - return -1; - } - - ACE_HANDLE handle = event_handler->get_handle (); - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - return this->resume_handler_i (handle); -} - -int -ACE_Dev_Poll_Reactor::resume_handler (ACE_HANDLE handle) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::resume_handler"); - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - return this->resume_handler_i (handle); -} - -int -ACE_Dev_Poll_Reactor::resume_handler (const ACE_Handle_Set &handles) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::resume_handler"); - - ACE_Handle_Set_Iterator handle_iter (handles); - ACE_HANDLE h; - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - while ((h = handle_iter ()) != ACE_INVALID_HANDLE) - if (this->resume_handler_i (h) == -1) - return -1; - - return 0; -} - -int -ACE_Dev_Poll_Reactor::resume_handlers (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::resume_handlers"); - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - size_t const len = this->handler_rep_.max_size (); - - for (size_t i = 0; i < len; ++i) - { - Event_Tuple *info = this->handler_rep_.find (i); - if (info != 0 && info->suspended && this->resume_handler_i (i) != 0) - return -1; - } - - return 0; -} - -int -ACE_Dev_Poll_Reactor::resume_handler_i (ACE_HANDLE handle) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::resume_handler_i"); - - Event_Tuple *info = this->handler_rep_.find (handle); - if (info == 0) - return -1; - - if (!info->suspended) - return 0; - - ACE_Reactor_Mask mask = info->mask; - if (mask == ACE_Event_Handler::NULL_MASK) - { - info->suspended = false; - return 0; - } - - // Place the handle back in to the "interest set." - // - // Events for the given handle will once again be polled. - -#if defined (ACE_HAS_EVENT_POLL) - - struct epoll_event epev; - ACE_OS::memset (&epev, 0, sizeof (epev)); - int op = EPOLL_CTL_ADD; - if (info->controlled) - op = EPOLL_CTL_MOD; - epev.events = this->reactor_mask_to_poll_event (mask) | EPOLLONESHOT; - epev.data.fd = handle; - - if (::epoll_ctl (this->poll_fd_, op, handle, &epev) == -1) - return -1; - info->controlled = true; - -#else - - struct pollfd pfd[1]; - - pfd[0].fd = handle; - pfd[0].events = this->reactor_mask_to_poll_event (mask); - pfd[0].revents = 0; - - if (ACE_OS::write (this->poll_fd_, pfd, sizeof (pfd)) != sizeof (pfd)) - return -1; - -#endif /* ACE_HAS_EVENT_POLL */ - - info->suspended = false; - - return 0; -} - -int -ACE_Dev_Poll_Reactor::resumable_handler (void) -{ - // @@ Is this correct? - - return 1; -} - -bool -ACE_Dev_Poll_Reactor::uses_event_associations (void) -{ - // Since the Dev_Poll_Reactor does not do any event associations, - // this method always return false. - return false; -} - -long -ACE_Dev_Poll_Reactor::schedule_timer (ACE_Event_Handler *event_handler, - const void *arg, - const ACE_Time_Value &delay, - const ACE_Time_Value &interval) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::schedule_timer"); - - ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); - - if (0 != this->timer_queue_) - return this->timer_queue_->schedule - (event_handler, - arg, - this->timer_queue_->gettimeofday () + delay, - interval); - - errno = ESHUTDOWN; - return -1; -} - -int -ACE_Dev_Poll_Reactor::reset_timer_interval (long timer_id, - const ACE_Time_Value &interval) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::reset_timer_interval"); - - ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); - - if (0 != this->timer_queue_) - return this->timer_queue_->reset_interval (timer_id, interval); - - errno = ESHUTDOWN; - return -1; -} - -int -ACE_Dev_Poll_Reactor::cancel_timer (ACE_Event_Handler *handler, - int dont_call_handle_close) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::cancel_timer"); - - // Don't bother waking the poll - the worse that will happen is it will - // wake up for a timer that doesn't exist then go back to waiting. - if ((this->timer_queue_ != 0) && (handler != 0)) - return this->timer_queue_->cancel (handler, dont_call_handle_close); - else - return 0; -} - -int -ACE_Dev_Poll_Reactor::cancel_timer (long timer_id, - const void **arg, - int dont_call_handle_close) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::cancel_timer"); - - // Don't bother waking the poll - the worse that will happen is it will - // wake up for a timer that doesn't exist then go back to waiting. - return (this->timer_queue_ == 0 - ? 0 - : this->timer_queue_->cancel (timer_id, - arg, - dont_call_handle_close)); -} - -int -ACE_Dev_Poll_Reactor::schedule_wakeup (ACE_Event_Handler *eh, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::schedule_wakeup"); - - return this->mask_ops (eh->get_handle (), mask, ACE_Reactor::ADD_MASK); -} - -int -ACE_Dev_Poll_Reactor::schedule_wakeup (ACE_HANDLE handle, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::schedule_wakeup"); - - return this->mask_ops (handle, mask, ACE_Reactor::ADD_MASK); -} - -int -ACE_Dev_Poll_Reactor::cancel_wakeup (ACE_Event_Handler *eh, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::cancel_wakeup"); - - return this->mask_ops (eh->get_handle (), mask, ACE_Reactor::CLR_MASK); -} - -int -ACE_Dev_Poll_Reactor::cancel_wakeup (ACE_HANDLE handle, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::cancel_wakeup"); - - return this->mask_ops (handle, mask, ACE_Reactor::CLR_MASK); -} - -int -ACE_Dev_Poll_Reactor::notify (ACE_Event_Handler *eh, - ACE_Reactor_Mask mask, - ACE_Time_Value *timeout) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::notify"); - - ssize_t n = 0; - - // Pass over both the Event_Handler *and* the mask to allow the - // caller to dictate which Event_Handler method the receiver - // invokes. Note that this call can timeout. - - n = this->notify_handler_->notify (eh, mask, timeout); - - return n == -1 ? -1 : 0; -} - -void -ACE_Dev_Poll_Reactor::max_notify_iterations (int iterations) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::max_notify_iterations"); - - ACE_MT (ACE_GUARD (ACE_Dev_Poll_Reactor_Token, mon, this->token_)); - - this->notify_handler_->max_notify_iterations (iterations); -} - -int -ACE_Dev_Poll_Reactor::max_notify_iterations (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::max_notify_iterations"); - - ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, -1)); - - return this->notify_handler_->max_notify_iterations (); -} - -int -ACE_Dev_Poll_Reactor::purge_pending_notifications (ACE_Event_Handler * eh, - ACE_Reactor_Mask mask) -{ - if (this->notify_handler_ == 0) - return 0; - - return this->notify_handler_->purge_pending_notifications (eh, mask); -} - -ACE_Event_Handler * -ACE_Dev_Poll_Reactor::find_handler (ACE_HANDLE handle) -{ - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, 0)); - - Event_Tuple *info = this->handler_rep_.find (handle); - if (info) - { - info->event_handler->add_reference (); - return info->event_handler; - } - else - { - return 0; - } -} - -int -ACE_Dev_Poll_Reactor::handler (ACE_HANDLE handle, - ACE_Reactor_Mask mask, - ACE_Event_Handler **event_handler) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::handler"); - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - Event_Tuple *info = this->handler_rep_.find (handle); - - if (info != 0 - && ACE_BIT_CMP_MASK (info->mask, - mask, // Compare all bits in the mask - mask)) - { - if (event_handler != 0) - *event_handler = info->event_handler; - - return 0; - } - - return -1; -} - -int -ACE_Dev_Poll_Reactor::handler (int signum, - ACE_Event_Handler **eh) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::handler"); - - ACE_Event_Handler *handler = this->signal_handler_->handler (signum); - - if (handler == 0) - return -1; - else if (eh != 0) - *eh = handler; - - return 0; -} - -bool -ACE_Dev_Poll_Reactor::initialized (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::initialized"); - - ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, false)); - - return this->initialized_; -} - -size_t -ACE_Dev_Poll_Reactor::size (void) const -{ - return this->handler_rep_.size (); -} - -ACE_Lock & -ACE_Dev_Poll_Reactor::lock (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::lock"); - - return this->lock_adapter_; -} - -void -ACE_Dev_Poll_Reactor::wakeup_all_threads (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::wakeup_all_threads"); - - // Send a notification, but don't block if there's no one to receive - // it. - this->notify (0, - ACE_Event_Handler::NULL_MASK, - (ACE_Time_Value *) &ACE_Time_Value::zero); -} - -int -ACE_Dev_Poll_Reactor::owner (ACE_thread_t /* new_owner */, - ACE_thread_t * /* old_owner */) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::owner"); - - // There is no need to set the owner of the event loop. Multiple - // threads may invoke the event loop simulataneously. - - return 0; -} - -int -ACE_Dev_Poll_Reactor::owner (ACE_thread_t * /* owner */) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::owner"); - - // There is no need to set the owner of the event loop. Multiple - // threads may invoke the event loop simulataneously. - - return 0; -} - -bool -ACE_Dev_Poll_Reactor::restart (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::restart"); - - ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, false)); - - return this->restart_; -} - -bool -ACE_Dev_Poll_Reactor::restart (bool r) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::restart"); - - ACE_MT (ACE_GUARD_RETURN (ACE_Dev_Poll_Reactor_Token, mon, this->token_, false)); - - bool current_value = this->restart_; - this->restart_ = r; - return current_value; -} - -void -ACE_Dev_Poll_Reactor::requeue_position (int) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::requeue_position"); -} - -int -ACE_Dev_Poll_Reactor::requeue_position (void) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::requeue_position"); - - ACE_NOTSUP_RETURN (-1); -} - -int -ACE_Dev_Poll_Reactor::mask_ops (ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask, - int ops) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::mask_ops"); - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - return this->mask_ops_i (event_handler->get_handle (), mask, ops); -} - -int -ACE_Dev_Poll_Reactor::mask_ops (ACE_HANDLE handle, - ACE_Reactor_Mask mask, - int ops) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::mask_ops"); - - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, grd, this->repo_lock_, -1)); - - return this->mask_ops_i (handle, mask, ops); -} - -int -ACE_Dev_Poll_Reactor::mask_ops_i (ACE_HANDLE handle, - ACE_Reactor_Mask mask, - int ops) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::mask_ops_i"); - - Event_Tuple *info = this->handler_rep_.find (handle); - if (info == 0) - return -1; - - // Block out all signals until method returns. - ACE_Sig_Guard sb; - - ACE_Reactor_Mask const old_mask = info->mask; - ACE_Reactor_Mask new_mask = old_mask; - - // Perform GET, CLR, SET, and ADD operations on the interest/wait - // set and the suspend set (if necessary). - // - // GET = 1, Retrieve current value - // SET = 2, Set value of bits to new mask (changes the entire mask) - // ADD = 3, Bitwise "or" the value into the mask (only changes - // enabled bits) - // CLR = 4 Bitwise "and" the negation of the value out of the mask - // (only changes enabled bits) - // - // Returns the original mask. - - switch (ops) - { - case ACE_Reactor::GET_MASK: - // The work for this operation is done in all cases at the - // beginning of the function. - return old_mask; - - case ACE_Reactor::CLR_MASK: - ACE_CLR_BITS (new_mask, mask); - break; - - case ACE_Reactor::SET_MASK: - new_mask = mask; - break; - - case ACE_Reactor::ADD_MASK: - ACE_SET_BITS (new_mask, mask); - break; - - default: - return -1; - } - - /// Reset the mask for the given handle. - info->mask = new_mask; - - // Only attempt to alter events for the handle from the - // "interest set" if it hasn't been suspended. If it has been - // suspended, the revised mask will take affect when the - // handle is resumed. The exception is if all the mask bits are - // cleared, we can un-control the fd now. - if (!info->suspended || (info->controlled && new_mask == 0)) - { - - short const events = this->reactor_mask_to_poll_event (new_mask); - -#if defined (sun) - // Apparently events cannot be updated on-the-fly on Solaris so - // remove the existing events, and then add the new ones. - struct pollfd pfd[2]; - - pfd[0].fd = handle; - pfd[0].events = POLLREMOVE; - pfd[0].revents = 0; - pfd[1].fd = (events == POLLREMOVE ? ACE_INVALID_HANDLE : handle); - pfd[1].events = events; - pfd[1].revents = 0; - - // Change the events associated with the given file descriptor. - if (ACE_OS::write (this->poll_fd_, - pfd, - sizeof (pfd)) != sizeof (pfd)) - return -1; -#elif defined (ACE_HAS_EVENT_POLL) - - struct epoll_event epev; - ACE_OS::memset (&epev, 0, sizeof (epev)); - int op; - - // ACE_Event_Handler::NULL_MASK ??? - if (new_mask == 0) - { - op = EPOLL_CTL_DEL; - epev.events = 0; - } - else - { - op = EPOLL_CTL_MOD; - epev.events = events | EPOLLONESHOT; - } - - epev.data.fd = handle; - - if (::epoll_ctl (this->poll_fd_, op, handle, &epev) == -1) - { - // If a handle is closed, epoll removes it from the poll set - // automatically - we may not know about it yet. If that's the - // case, a mod operation will fail with ENOENT. Retry it as - // an add. If it's any other failure, just fail outright. - if (op != EPOLL_CTL_MOD || errno != ENOENT || - ::epoll_ctl (this->poll_fd_, EPOLL_CTL_ADD, handle, &epev) == -1) - return -1; - } - info->controlled = (op != EPOLL_CTL_DEL); -#else - pollfd pfd[1]; - - pfd[0].fd = handle; - pfd[0].events = events; - pfd[0].revents = 0; - - // Change the events associated with the given file descriptor. - if (ACE_OS::write (this->poll_fd_, - pfd, - sizeof (pfd)) != sizeof (pfd)) - return -1; -#endif /*ACE_HAS_EVENT_POLL */ - } - - return old_mask; -} - -int -ACE_Dev_Poll_Reactor::ready_ops (ACE_Event_Handler * /* event_handler */, - ACE_Reactor_Mask /* mask */, - int /* ops */) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::ready_ops"); - - // Since the Dev_Poll_Reactor uses the poll result buffer, the - // ready_set cannot be directly manipulated outside of the event - // loop. - ACE_NOTSUP_RETURN (-1); -} - -int -ACE_Dev_Poll_Reactor::ready_ops (ACE_HANDLE /* handle */, - ACE_Reactor_Mask /* mask */, - int /* ops */) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::ready_ops"); - - // Since the Dev_Poll_Reactor uses the poll result buffer, the - // ready_set cannot be directly manipulated outside of the event - // loop. - ACE_NOTSUP_RETURN (-1); -} - -void -ACE_Dev_Poll_Reactor::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Dev_Poll_Reactor::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("restart_ = %d\n"), this->restart_)); - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("initialized_ = %d"), - this->initialized_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("poll_fd_ = %d"), this->poll_fd_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("size_ = %u"), this->handler_rep_.size ())); - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("deactivated_ = %d"), - this->deactivated_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -short -ACE_Dev_Poll_Reactor::reactor_mask_to_poll_event (ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::reactor_mask_to_poll_event"); - - if (mask == ACE_Event_Handler::NULL_MASK) - // No event. Remove from interest set. -#if defined (ACE_HAS_EVENT_POLL) - return EPOLL_CTL_DEL; -#else - return POLLREMOVE; -#endif /* ACE_HAS_EVENT_POLL */ - - short events = 0; - - // READ, ACCEPT, and CONNECT flag will place the handle in the - // read set. - if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::READ_MASK) - || ACE_BIT_ENABLED (mask, ACE_Event_Handler::ACCEPT_MASK) - || ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK)) - { -#if defined (ACE_HAS_EVENT_POLL) - ACE_SET_BITS (events, EPOLLIN); -#else - ACE_SET_BITS (events, POLLIN); -#endif /*ACE_HAS_EVENT_POLL*/ - } - - // WRITE and CONNECT flag will place the handle in the write set. - if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::WRITE_MASK) - || ACE_BIT_ENABLED (mask, ACE_Event_Handler::CONNECT_MASK)) - { -#if defined (ACE_HAS_EVENT_POLL) - ACE_SET_BITS (events, EPOLLOUT); -#else - ACE_SET_BITS (events, POLLOUT); -#endif /*ACE_HAS_EVENT_POLL*/ - } - - // EXCEPT flag will place the handle in the except set. - if (ACE_BIT_ENABLED (mask, ACE_Event_Handler::EXCEPT_MASK)) - { -#if defined (ACE_HAS_EVENT_POLL) - ACE_SET_BITS (events, EPOLLPRI); -#else - ACE_SET_BITS (events, POLLPRI); -#endif /*ACE_HAS_EVENT_POLL*/ - } - - return events; -} - -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) -namespace { - void polite_sleep_hook (void *) { } -} -#endif - -int -ACE_Dev_Poll_Reactor::Token_Guard::acquire_quietly (ACE_Time_Value *max_wait) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Token_Guard::acquire_quietly"); - - // Acquire the token but don't ping any waiters; just queue up politely. - int result = 0; - if (max_wait) - { - ACE_Time_Value tv = ACE_OS::gettimeofday (); - tv += *max_wait; - - ACE_MT (result = this->token_.acquire_read (&polite_sleep_hook, - 0, - &tv)); - } - else - { - ACE_MT (result = this->token_.acquire_read (&polite_sleep_hook)); - } - - // Check for timeouts and errors. - if (result == -1) - { - if (errno == ETIME) - return 0; - else - { - ACELIB_ERROR ((LM_ERROR, ACE_TEXT("%t: %p\n"), ACE_TEXT("token acquire_read"))); - return -1; - } - } - - // We got the token and so let us mark ourselves as owner - this->owner_ = true; - - return result; -} - -int -ACE_Dev_Poll_Reactor::Token_Guard::acquire (ACE_Time_Value *max_wait) -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Token_Guard::acquire"); - - // Try to grab the token. If someone if already there, don't wake - // them up, just queue up in the thread pool. - int result = 0; - if (max_wait) - { - ACE_Time_Value tv = ACE_OS::gettimeofday (); - tv += *max_wait; - - ACE_MT (result = this->token_.acquire (0, 0, &tv)); - } - else - { - ACE_MT (result = this->token_.acquire ()); - } - - // Check for timeouts and errors. - if (result == -1) - { - if (errno == ETIME) - return 0; - else - return -1; - } - - // We got the token and so let us mark ourseleves as owner - this->owner_ = true; - - return result; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_EVENT_POLL || ACE_HAS_DEV_POLL */ diff --git a/deps/acelite/ace/Dev_Poll_Reactor.h b/deps/acelite/ace/Dev_Poll_Reactor.h deleted file mode 100644 index ed8640a30..000000000 --- a/deps/acelite/ace/Dev_Poll_Reactor.h +++ /dev/null @@ -1,1198 +0,0 @@ -// -*- C++ -*- - -// ========================================================================= -/** - * @file Dev_Poll_Reactor.h - * - * @c /dev/poll (or Linux @c sys_epoll) based Reactor implementation. - * - * @author Ossama Othman - */ -// ========================================================================= - - -#ifndef ACE_DEV_POLL_REACTOR_H -#define ACE_DEV_POLL_REACTOR_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_EVENT_POLL) && defined (ACE_HAS_DEV_POLL) -# error ACE_HAS_EVENT_POLL and ACE_HAS_DEV_POLL are mutually exclusive. -#endif /* ACE_HAS_EVENT_POLL && defined ACE_HAS_DEV_POLL */ - -#if defined (ACE_HAS_EVENT_POLL) || defined (ACE_HAS_DEV_POLL) - -#include "ace/Pipe.h" -#include "ace/Lock_Adapter_T.h" -#include "ace/Reactor_Impl.h" -#include "ace/Reactor_Token_T.h" -#include "ace/Token.h" - -#if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) -# include "ace/Notification_Queue.h" -#endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ - -#if defined (ACE_HAS_DEV_POLL) -struct pollfd; -#elif defined (ACE_HAS_EVENT_POLL) -# include "ace/Array_Map.h" -# include /**/ -#endif - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward declarations -class ACE_Sig_Handler; -class ACE_Dev_Poll_Reactor; - -// --------------------------------------------------------------------- - -/** - * @class ACE_Dev_Poll_Reactor_Notify - * - * @brief Event handler used for unblocking the ACE_Dev_Poll_Reactor - * from its event loop. - * - * This event handler is used internally by the ACE_Dev_Poll_Reactor - * as a means to allow a thread other then the one running the event - * loop to unblock the event loop. - */ -class ACE_Dev_Poll_Reactor_Notify : public ACE_Reactor_Notify -{ -public: - /// Constructor - ACE_Dev_Poll_Reactor_Notify (void); - - /** - * @name Initialization and Termination Methods - * - * Methods called when initializing and terminating this event - * handler. - */ - virtual int open (ACE_Reactor_Impl *, - ACE_Timer_Queue *timer_queue = 0, - int disable_notify = 0); - virtual int close (void); - - /** - * Called by a thread when it wants to unblock the Reactor_Impl. - * This wakes up the Reactor_Impl if currently blocked. Pass over - * both the Event_Handler and the mask to allow the caller to - * dictate which Event_Handler method the Reactor_Impl will - * invoke. The ACE_Time_Value indicates how long to block - * trying to notify the Reactor_Impl. If timeout == 0, the - * caller will block until action is possible, else will wait until - * the relative time specified in *timeout elapses). - */ - virtual int notify (ACE_Event_Handler *eh = 0, - ACE_Reactor_Mask mask = ACE_Event_Handler::EXCEPT_MASK, - ACE_Time_Value *timeout = 0); - - /// Unimplemented method required by pure virtual method in abstract - /// base class. - /** - * This method's interface is not very compatible with this - * Reactor's design. It's not clear why this method is pure virtual - * either. - */ - virtual int dispatch_notifications (int &number_of_active_handles, - ACE_Handle_Set &rd_mask); - - /// Returns the ACE_HANDLE of the notify pipe on which the reactor - /// is listening for notifications so that other threads can unblock - /// the Reactor_Impl. - virtual ACE_HANDLE notify_handle (void); - - /// Verify whether the buffer has dispatchable info or not. - virtual int is_dispatchable (ACE_Notification_Buffer &buffer); - - /// Handle one notify call represented in @a buffer. This could be - /// because of a thread trying to unblock the Reactor_Impl. - virtual int dispatch_notify (ACE_Notification_Buffer &buffer); - - /// Read one notify call on the handle into @a buffer. - /// This could be because of a thread trying to unblock the Reactor_Impl. - virtual int read_notify_pipe (ACE_HANDLE handle, - ACE_Notification_Buffer &buffer); - - /// Called back by the ACE_Dev_Poll_Reactor when a thread wants to - /// unblock us. - virtual int handle_input (ACE_HANDLE handle); - - /** - * Set the maximum number of times that the handle_input method - * will iterate and dispatch the ACE_Event_Handlers that are - * passed in via the notify queue before breaking out of the event - * loop. By default, this is set to -1, which means "iterate until - * the queue is empty." Setting this to a value like "1 or 2" will - * increase "fairness" (and thus prevent starvation) at the expense - * of slightly higher dispatching overhead. - */ - virtual void max_notify_iterations (int); - - /** - * Get the maximum number of times that the handle_input method - * will iterate and dispatch the ACE_Event_Handlers that are - * passed in via the notify queue before breaking out of its event - * loop. - */ - virtual int max_notify_iterations (void); - - /** - * Purge any notifications pending in this reactor for the specified - * ACE_Event_Handler object. Returns the number of notifications - * purged. Returns -1 on error. - */ - virtual int purge_pending_notifications ( - ACE_Event_Handler * = 0, - ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK); - - /// Dump the state of an object. - virtual void dump (void) const; - - /// Method called by ACE_Dev_Poll_Reactor to obtain one notification. - /// THIS METHOD MUST BE CALLED WITH THE REACTOR TOKEN HELD! - /// - /// @return -1 on error, else 0 and @arg nb has the notify to - /// dispatch. Note that the contained event handler may be - /// 0 if there were only wake-ups (no handlers to dispatch). - int dequeue_one (ACE_Notification_Buffer &nb); - - ACE_ALLOC_HOOK_DECLARE; - -protected: - - /** - * Keep a back pointer to the ACE_Dev_Poll_Reactor. If this value - * if NULL then the ACE_Dev_Poll_Reactor has been initialized with - * disable_notify_pipe. - */ - ACE_Dev_Poll_Reactor *dp_reactor_; - - /** - * Contains the ACE_HANDLE the ACE_Dev_Poll_Reactor is listening - * on, as well as the ACE_HANDLE that threads wanting the attention - * of the ACE_Dev_Poll_Reactor will write to. - */ - ACE_Pipe notification_pipe_; - - /** - * Keeps track of the maximum number of times that the - * ACE_Dev_Poll_Reactor_Notify::handle_input method will iterate and - * dispatch the ACE_Event_Handlers that are passed in via the - * notify pipe before breaking out of its recv loop. By default, - * this is set to -1, which means "iterate until the pipe is empty." - */ - int max_notify_iterations_; - -#if defined (ACE_HAS_REACTOR_NOTIFICATION_QUEUE) - /** - * @brief A user-space queue to store the notifications. - * - * The notification pipe has OS-specific size restrictions. That - * is, no more than a certain number of bytes may be stored in the - * pipe without blocking. This limit may be too small for certain - * applications. In this case, ACE can be configured to store all - * the events in user-space. The pipe is still needed to wake up - * the reactor thread, but only one event is sent through the pipe - * at a time. - */ - ACE_Notification_Queue notification_queue_; -#endif /* ACE_HAS_REACTOR_NOTIFICATION_QUEUE */ -}; - -// --------------------------------------------------------------------- - -/** - * @class ACE_Dev_Poll_Reactor - * - * @brief A `/dev/poll' or `/dev/epoll' based Reactor implemenatation. - * - * @attention The Linux epoll implementation works quite well and is - * fully supported; however, the /dev/poll implementation is @em experimental. - * - * The ACE_Dev_Poll_Reactor uses the `/dev/poll' or '/dev/epoll' - * character devices to demultiplex events on a given set of file - * descriptors. Unlike @c select(), `/dev/poll' and `/dev/epoll' have - * no hard-coded limit on the number of file descriptors that may be - * handled at any given time. As such, the ACE_Dev_Poll_Reactor can - * generally handle a much larger number of file descriptors than - * @c select() -based reactors. Furthermore, since `/dev/poll' and - * `/dev/epoll' both return a set of file descriptors that are active, - * there is no need to "walk" the set of file descriptors to determine - * which ones are active, such as what is done with the @c select() and - * @c poll() system calls. All returned file descriptors are active. - * This makes event dispatching very efficient. - * - * @note In general, this reactor may only be used to demultiplex - * events on sockets. Demultiplexing events on pipes, for - * example may not work. This is due to a limitation in the - * underlying `/dev/poll' device driver. - * - * @note It is only possible to achieve millisecond timeout - * resolutions with the @c ACE_Dev_Poll_Reactor. However, the - * timeout resolution for timers is independent of the reactors - * timeout resolution. As such, it may be possible to achieve - * sub-millisecond timeout resolutions for timers but that is - * entirely platform dependent. - */ - -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) -typedef ACE_Token ACE_DEV_POLL_TOKEN; -#else -typedef ACE_Noop_Token ACE_DEV_POLL_TOKEN; -#endif /* ACE_MT_SAFE && ACE_MT_SAFE != 0 */ -typedef ACE_Reactor_Token_T ACE_Dev_Poll_Reactor_Token; - -class ACE_Export ACE_Dev_Poll_Reactor : public ACE_Reactor_Impl -{ - - /** - * @struct Event_Tuple - * - * @brief Struct that collects event registration information for a handle. - * - * @internal Internal use only - * - * This struct merely provides a means to associate an event mask - * with an event handler. Such an association is needed since it is - * not possible to retrieve the event mask from the "interest set" - * stored in the `/dev/poll' or `/dev/epoll' driver. Without this - * external association, it would not be possible keep track of the - * event mask for a given event handler when suspending it or resuming - * it. - * - * @note An ACE_Handle_Set is not used since the number of handles may - * exceed its capacity (ACE_DEFAULT_SELECT_REACTOR_SIZE). - */ - struct Event_Tuple - { - /// Constructor to set up defaults. - Event_Tuple (ACE_Event_Handler *eh = 0, - ACE_Reactor_Mask m = ACE_Event_Handler::NULL_MASK, - bool is_suspended = false, - bool is_controlled = false); - - /// The event handler. - ACE_Event_Handler *event_handler; - - /// The event mask for the above event handler. - ACE_Reactor_Mask mask; - - /// Flag that states whether or not the event handler is suspended. - bool suspended; - - /// Flag to say whether or not this handle is registered with epoll. - bool controlled; - - ACE_ALLOC_HOOK_DECLARE; - }; - - - // --------------------------------------------------------------------- - - /** - * @class Handler_Repository - * - * @internal - * - * @brief Used to map ACE_HANDLEs onto the appropriate Event_Tuple. - * - * This class is simply a container that maps a handle to its - * corresponding event tuple. It is not meant for use outside of - * the Dev_Poll_Reactor. - * - * @note Calls to any method in this class, and any modification to a - * Event_Tuple returned from this class's methods, must be made - * while holding the repository lock. - */ - class Handler_Repository - { - public: - /// Constructor. - Handler_Repository (void); - - /// Initialize a repository that can map handles up to the value @a size. - /// Since the event tuples are accessed directly using the handle as - /// an index, @a size sets the maximum handle value, minus 1. - int open (size_t size); - - /// Close down the repository. - int close (void); - - /** - * @name Repository Manipulation Operations - * - * Methods used to search and modify the handler repository. - */ - //@{ - - /// Return a pointer to the Event_Tuple associated with @a handle. - /// If there is none associated, returns 0 and sets errno. - Event_Tuple *find (ACE_HANDLE handle); - - - /// Bind the ACE_Event_Handler to the @c ACE_HANDLE with the - /// appropriate ACE_Reactor_Mask settings. - int bind (ACE_HANDLE handle, - ACE_Event_Handler *handler, - ACE_Reactor_Mask mask); - - /// Remove the binding for @a handle; optionally decrement the associated - /// handler's reference count. - int unbind (ACE_HANDLE handle, bool decr_refcnt = true); - - /// Remove all the registered tuples. - int unbind_all (void); - - //@} - - /** - * @name Sanity Checking - * - * Methods used to prevent "out-of-range" errors when indexing the - * underlying handler array. - */ - //@{ - - // Check the @a handle to make sure it's a valid @c ACE_HANDLE that - // within the range of legal handles (i.e., greater than or equal to - // zero and less than @c max_size_). - bool invalid_handle (ACE_HANDLE handle) const; - - // Check the handle to make sure it's a valid @c ACE_HANDLE that is - // within the range of currently registered handles (i.e., greater - // than or equal to zero and less than @c max_handlep1_). - bool handle_in_range (ACE_HANDLE handle) const; - - //@} - - /// Returns the current table size. - size_t size (void) const; - - /// Returns the maximum table size. - size_t max_size (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - private: - /// Current number of handles. - int size_; - - /// Maximum number of handles. - int max_size_; - - /// The underlying array of event handlers. - /** - * The array of event handlers is directly indexed directly using - * an @c ACE_HANDLE value. This is Unix-specific. - */ - Event_Tuple *handlers_; - - }; - -public: - /// Initialize @c ACE_Dev_Poll_Reactor with the default size. - /** - * The default size for the @c ACE_Dev_Poll_Reactor is the maximum - * number of open file descriptors for the process. - */ - ACE_Dev_Poll_Reactor (ACE_Sig_Handler * = 0, - ACE_Timer_Queue * = 0, - int disable_notify_pipe = 0, - ACE_Reactor_Notify *notify = 0, - int mask_signals = 1, - int s_queue = ACE_DEV_POLL_TOKEN::FIFO); - - /// Initialize ACE_Dev_Poll_Reactor with size @a size. - /** - * @note On Unix platforms, the @a size parameter should be as large - * as the maximum number of file descriptors allowed for a - * given process. This is necessary since a file descriptor - * is used to directly index the array of event handlers - * maintained by the Reactor's handler repository. Direct - * indexing is used for efficiency reasons. If the size - * parameter is less than the process maximum, the process - * maximum will be decreased in order to prevent potential - * access violations. - */ - ACE_Dev_Poll_Reactor (size_t size, - bool restart = false, - ACE_Sig_Handler * = 0, - ACE_Timer_Queue * = 0, - int disable_notify_pipe = 0, - ACE_Reactor_Notify *notify = 0, - int mask_signals = 1, - int s_queue = ACE_DEV_POLL_TOKEN::FIFO); - - /// Close down and release all resources. - virtual ~ACE_Dev_Poll_Reactor (void); - - /// Initialization. - virtual int open (size_t size, - bool restart = false, - ACE_Sig_Handler * = 0, - ACE_Timer_Queue * = 0, - int disable_notify_pipe = 0, - ACE_Reactor_Notify * = 0); - - /** - * @param handle allows the reactor to check if the caller is - * valid. - * - * @return 0 if the size of the current message has been put in - * size. -1 if not. - */ - virtual int current_info (ACE_HANDLE handle, size_t & /* size */); - - /// Use a user specified signal handler instead. - virtual int set_sig_handler (ACE_Sig_Handler *signal_handler); - - /// Set a user-specified timer queue. - virtual int timer_queue (ACE_Timer_Queue *tq); - - /// Get the timer queue - /// @return The current @c ACE_Timer_Queue. - virtual ACE_Timer_Queue *timer_queue (void) const; - - /// Close down and release all resources. - virtual int close (void); - - // = Event loop drivers. - /** - * Returns non-zero if there are I/O events "ready" for dispatching, - * but does not actually dispatch the event handlers. By default, - * don't block while checking this, i.e., "poll". - * - * @note It is only possible to achieve millisecond timeout - * resolutions with the @c ACE_Dev_Poll_Reactor. - */ - virtual int work_pending ( - const ACE_Time_Value &max_wait_time = ACE_Time_Value::zero); - - /** - * This event loop driver blocks for up to @a max_wait_time before - * returning. It will return earlier if events occur. Note that - * @a max_wait_time can be 0, in which case this method blocks - * indefinitely until events occur. - * @par - * @a max_wait_time is decremented to reflect how much time this - * call took. For instance, if a time value of 3 seconds is passed - * to @c handle_events() and an event occurs after 2 seconds, - * @a max_wait_time will equal 1 second. This can be used if an - * application wishes to handle events for some fixed amount of - * time. - * @par - * The only difference between @c alertable_handle_events() and - * handle_events() is that in the alertable case, the event loop - * will return when the system queues an I/O completion routine or - * an Asynchronous Procedure Call. - * - * @return The total number of @c ACE_Event_Handlers that were - * dispatched, 0 if the @a max_wait_time elapsed without - * dispatching any handlers, or -1 if an error occurs. - - * @note It is only possible to achieve millisecond timeout - * resolutions with the @c ACE_Dev_Poll_Reactor. - */ - virtual int handle_events (ACE_Time_Value *max_wait_time = 0); - virtual int alertable_handle_events (ACE_Time_Value *max_wait_time = 0); - - /** - * This method is just like the one above, except the - * @a max_wait_time value is a reference and can therefore never be - * @c NULL. - * - * @note It is only possible to achieve millisecond timeout - * resolutions with the @c ACE_Dev_Poll_Reactor. - */ - virtual int handle_events (ACE_Time_Value &max_wait_time); - virtual int alertable_handle_events (ACE_Time_Value &max_wait_time); - - // = Event handling control. - - /** - * @return The status of Reactor. If this function returns 0, the - * reactor is actively handling events. If it returns - * non-zero, @c handle_events() and - * @c handle_alertable_events() return -1 immediately. - */ - virtual int deactivated (void); - - /** - * Control whether the Reactor will handle any more incoming events - * or not. If @a do_stop == 1, the Reactor will be disabled. By - * default, a reactor is in active state and can be - * deactivated/reactived as desired. - */ - virtual void deactivate (int do_stop); - - // = Register and remove Handlers. - - /// Register @a event_handler with @a mask. The I/O handle will - /// always come from get_handle on the event_handler. - virtual int register_handler (ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask); - - /// Register @a event_handler with @a mask. The I/O handle is - /// provided through the @a io_handle parameter. - virtual int register_handler (ACE_HANDLE io_handle, - ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask); - - /** - * Register an @a event_handler that will be notified when - * @a event_handle is signaled. @a mask specifies the network - * events that the @a event_handler is interested in. - */ - virtual int register_handler (ACE_HANDLE event_handle, - ACE_HANDLE io_handle, - ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask); - - /// Register @a event_handler with all the @a handles in the @c - /// Handle_Set. - virtual int register_handler (const ACE_Handle_Set &handles, - ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask); - - /** - * Register @a new_sh to handle the signal @a signum using the - * @a new_disp. Returns the @a old_sh that was previously - * registered (if any), along with the @a old_disp of the signal - * handler. - */ - virtual int register_handler (int signum, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp = 0, - ACE_Event_Handler **old_sh = 0, - ACE_Sig_Action *old_disp = 0); - - /// Registers @a new_sh to handle a set of signals @a sigset using the - /// @a new_disp. - virtual int register_handler (const ACE_Sig_Set &sigset, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp = 0); - - /// Removes @a event_handler. - /** - * @note The I/O handle will be obtained using @c get_handle() - * method of @a event_handler . If @a mask == - * @c ACE_Event_Handler::DONT_CALL then the @c handle_close() - * method of the @a event_handler is not invoked. - */ - virtual int remove_handler (ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask); - - /** - * Removes @a handle. If @a mask == ACE_Event_Handler::DONT_CALL - * then the method of the associated - * is not invoked. - */ - virtual int remove_handler (ACE_HANDLE handle, - ACE_Reactor_Mask mask); - - /** - * Removes all handles in @a handle_set. If @a mask == - * ACE_Event_Handler::DONT_CALL then the method of - * the associated s is not invoked. - */ - virtual int remove_handler (const ACE_Handle_Set &handle_set, - ACE_Reactor_Mask mask); - - /** - * Remove the ACE_Event_Handler currently associated with @a signum. - * Install the new disposition (if given) and return the previous - * disposition (if desired by the caller). Returns 0 on success and - * -1 if @a signum is invalid. - */ - virtual int remove_handler (int signum, - ACE_Sig_Action *new_disp, - ACE_Sig_Action *old_disp = 0, - int sigkey = -1); - - /// Calls for every signal in @a sigset. - virtual int remove_handler (const ACE_Sig_Set &sigset); - - // = Suspend and resume Handlers. - - /// Suspend event_handler temporarily. Use - /// ACE_Event_Handler::get_handle() to get the handle. - virtual int suspend_handler (ACE_Event_Handler *event_handler); - - /// Suspend handle temporarily. - virtual int suspend_handler (ACE_HANDLE handle); - - /// Suspend all handles in handle set temporarily. - virtual int suspend_handler (const ACE_Handle_Set &handles); - - /// Suspend all handles temporarily. - virtual int suspend_handlers (void); - - /// Resume event_handler. Use ACE_Event_Handler::get_handle() to - /// get the handle. - virtual int resume_handler (ACE_Event_Handler *event_handler); - - /// Resume handle. - virtual int resume_handler (ACE_HANDLE handle); - - /// Resume all handles in handle set. - virtual int resume_handler (const ACE_Handle_Set &handles); - - /// Resume all handles. - virtual int resume_handlers (void); - - /// Does the reactor allow the application to resume the handle on - /// its own, i.e., can it pass on the control of handle resumption to - /// the application. - virtual int resumable_handler (void); - - /// Return true if we any event associations were made by the reactor - /// for the handles that it waits on, false otherwise. - virtual bool uses_event_associations (void); - - // = Timer management. - - /** - * Schedule an ACE_Event_Handler that will expire after an amount - * of time. The return value of this method, a timer_id value, - * uniquely identifies the event_handler in the ACE_Reactor's - * internal list of timers. - * This timer_id value can be used to cancel the timer - * with the cancel_timer() call. - * - * @see cancel_timer() - * @see reset_timer_interval() - * - * @param event_handler event handler to schedule on reactor - * @param arg argument passed to the handle_timeout() method of - * event_handler. - * @param delay time interval after which the timer will expire. - * @param interval time interval for which the timer will be - * automatically rescheduled. - * @return -1 on failure, a timer_id value on success - */ - virtual long schedule_timer (ACE_Event_Handler *event_handler, - const void *arg, - const ACE_Time_Value &delay, - const ACE_Time_Value &interval = ACE_Time_Value::zero); - - /** - * Resets the interval of the timer represented by @a timer_id to - * @a interval, which is specified in relative time to the current - * . If @a interval is equal to - * ACE_Time_Value::zero, the timer will become a non-rescheduling - * timer. Returns 0 if successful, -1 if not. - */ - virtual int reset_timer_interval (long timer_id, - const ACE_Time_Value &interval); - - /// Cancel all Event_Handlers that match the address of - /// @a event_handler. Returns number of handlers cancelled. - virtual int cancel_timer (ACE_Event_Handler *event_handler, - int dont_call_handle_close = 1); - - /** - * Cancel the single event handler that matches the @a timer_id value - * (which was returned from the schedule method). If @a arg is - * non-NULL then it will be set to point to the ``magic cookie'' - * argument passed in when the event handler was registered. This - * makes it possible to free up the memory and avoid memory leaks. - * Returns 1 if cancellation succeeded and 0 if the @a timer_id - * wasn't found. - */ - virtual int cancel_timer (long timer_id, - const void **arg = 0, - int dont_call_handle_close = 1); - - // = High-level event handler scheduling operations - - /// Add @a masks_to_be_added to the @a event_handler's entry. - /// @a event_handler must already have been registered. - virtual int schedule_wakeup (ACE_Event_Handler *event_handler, - ACE_Reactor_Mask masks_to_be_added); - - /// Add @a masks_to_be_added to the @a handle's entry. - /// associated with @a handle must already have been registered. - virtual int schedule_wakeup (ACE_HANDLE handle, - ACE_Reactor_Mask masks_to_be_added); - - /// Clear @a masks_to_be_cleared from the @a event_handler's entry. - virtual int cancel_wakeup (ACE_Event_Handler *event_handler, - ACE_Reactor_Mask masks_to_be_cleared); - - /// Clear @a masks_to_be_cleared from the @a handle's entry. - virtual int cancel_wakeup (ACE_HANDLE handle, - ACE_Reactor_Mask masks_to_be_cleared); - - // = Notification methods. - - /** - * Notify @a event_handler of @a mask event. The ACE_Time_Value - * indicates how long to blocking trying to notify. If @a timeout == - * 0, the caller will block until action is possible, else will wait - * until the relative time specified in @a timeout elapses). - */ - virtual int notify (ACE_Event_Handler *event_handler = 0, - ACE_Reactor_Mask mask = ACE_Event_Handler::EXCEPT_MASK, - ACE_Time_Value * = 0); - - /** - * Set the maximum number of times that ACE_Reactor_Impl will - * iterate and dispatch the ACE_Event_Handlers that are passed in - * via the notify queue before breaking out of its - * ACE_Message_Queue::dequeue() loop. By default, this is set to - * -1, which means "iterate until the queue is empty." Setting this - * to a value like "1 or 2" will increase "fairness" (and thus - * prevent starvation) at the expense of slightly higher dispatching - * overhead. - */ - virtual void max_notify_iterations (int); - - /** - * Get the maximum number of times that the ACE_Reactor_Impl will - * iterate and dispatch the ACE_Event_Handlers that are passed in - * via the notify queue before breaking out of its - * ACE_Message_Queue::dequeue() loop. - */ - virtual int max_notify_iterations (void); - - /** - * Purge any notifications pending in this reactor for the specified - * ACE_Event_Handler object. Returns the number of notifications - * purged. Returns -1 on error. - */ - virtual int purge_pending_notifications (ACE_Event_Handler * = 0, - ACE_Reactor_Mask = ACE_Event_Handler::ALL_EVENTS_MASK); - - /** - * Return the Event_Handler associated with @a handle. Return 0 if - * @a handle is not registered. - */ - virtual ACE_Event_Handler *find_handler (ACE_HANDLE handle); - - /** - * Check to see if @a handle is associated with a valid Event_Handler - * bound to @a mask. Return the @a event_handler associated with this - * @c handler if @a event_handler != 0. - */ - virtual int handler (ACE_HANDLE handle, - ACE_Reactor_Mask mask, - ACE_Event_Handler **event_handler = 0); - - /** - * Check to see if @a signum is associated with a valid Event_Handler - * bound to a signal. Return the @a event_handler associated with - * this @c handler if @a event_handler != 0. - */ - virtual int handler (int signum, - ACE_Event_Handler ** = 0); - - /// Returns true if Reactor has been successfully initialized, else - /// false. - virtual bool initialized (void); - - /// Returns the current size of the Reactor's internal descriptor - /// table. - virtual size_t size (void) const; - - /// Returns a reference to the Reactor's internal repository lock. - virtual ACE_Lock &lock (void); - - /// Wake up all threads waiting in the event loop. - virtual void wakeup_all_threads (void); - - /// Transfers ownership of Reactor_Impl to the @a new_owner. - /** - * @note There is no need to set the owner of the event loop for the - * ACE_Dev_Poll_Reactor. Multiple threads may invoke the - * event loop simulataneously. As such, this method is a - * no-op. - */ - virtual int owner (ACE_thread_t new_owner, ACE_thread_t *old_owner = 0); - - /// Return the ID of the "owner" thread. - /** - * @note There is no need to set the owner of the event loop for the - * ACE_Dev_Poll_Reactor. Multiple threads may invoke the - * event loop simultaneously. As such, this method is a - * no-op. - */ - virtual int owner (ACE_thread_t *owner); - - /// Get the existing restart value. - virtual bool restart (void); - - /// Set a new value for restart and return the original value. - /** - * @param r If zero, then the event loop will not be automatically - * restarted if the underlying poll is interrupted via the - * INTR (interrupt) signal. - * - * @return Returns the previous "restart" value. - */ - virtual bool restart (bool r); - - /// Set position of the owner thread. - /** - * @note This is currently a no-op. - */ - virtual void requeue_position (int); - - /// Get position of the owner thread. - /** - * @note This is currently a no-op. - */ - virtual int requeue_position (void); - - /** - * @name Low-level wait_set mask manipulation methods - * - * Low-level methods to manipulate the event/reactor mask associated - * with a handle and event handler when polling for events. - * @par - * The "interest set," i.e. the wait set, can be directly - * manipulated with these methods. - */ - //@{ - - /// GET/SET/ADD/CLR the dispatch mask "bit" bound with the - /// event_handler and mask. - /** - * @return Old mask on success, -1 on error. - */ - virtual int mask_ops (ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask, - int ops); - - /// GET/SET/ADD/CLR the dispatch MASK "bit" bound with the handle - /// and mask. - /** - * @return Old mask on success, -1 on error. - */ - virtual int mask_ops (ACE_HANDLE handle, - ACE_Reactor_Mask mask, - int ops); - - //@} - - /** - * @name Low-level ready_set mask manipulation methods - * - * These methods are unimplemented. - */ - //@{ - - /// GET/SET/ADD/CLR the ready "bit" bound with the event_handler - /// and mask. - virtual int ready_ops (ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask, - int ops); - - /// GET/SET/ADD/CLR the ready "bit" bound with the handle and mask. - virtual int ready_ops (ACE_HANDLE handle, - ACE_Reactor_Mask, - int ops); - - //@} - - /// Dump the state of an object. - virtual void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - - class Token_Guard; - - /// Non-locking version of wait_pending(). - /** - * Returns non-zero if there are I/O events "ready" for dispatching, - * but does not actually dispatch the event handlers. By default, - * don't block while checking this, i.e., "poll". - * - * @note It is only possible to achieve millisecond timeout - * resolutions with the ACE_Dev_Poll_Reactor. - */ - int work_pending_i (ACE_Time_Value *max_wait_time); - - /// Poll for events and return the number of event handlers that - /// were dispatched. - /** - * This is a helper method called by all handle_events() methods. - */ - int handle_events_i (ACE_Time_Value *max_wait_time, Token_Guard &guard); - - /// Perform the upcall with the given event handler method. - int upcall (ACE_Event_Handler *event_handler, - int (ACE_Event_Handler::*callback)(ACE_HANDLE), - ACE_HANDLE handle); - - /** - * Dispatch ACE_Event_Handlers for time events, I/O events, and - * signal events. Returns the total number of ACE_Event_Handlers - * that were dispatched or -1 if something goes wrong. - */ - int dispatch (Token_Guard &guard); - - /// Dispatch a single timer, if ready. - /// Returns: 0 if no timers ready (token still held), - /// 1 if a timer was expired (token released), - /// -1 on error (token still held). - int dispatch_timer_handler (Token_Guard &guard); - - /// Dispatch an IO event to the corresponding event handler. Returns - /// Returns: 0 if no events ready (token still held), - /// 1 if an event was expired (token released), - /// -1 on error (token still held). - int dispatch_io_event (Token_Guard &guard); - - /// Register the given event handler with the reactor. - int register_handler_i (ACE_HANDLE handle, - ACE_Event_Handler *eh, - ACE_Reactor_Mask mask); - - /// Remove the event handler associated with the given handle and - /// event mask from the "interest set." If @a eh is supplied, only do the - /// remove if @eh matches the event handler that's registered for @a handle. - /// The caller is expected to be holding the repo token on entry and have - /// @repo_guard referencing that token. It will be temporarily released - /// during a handle_close() callback if needed; if it is released for the - //// callback it will be reacquired before return. - // FUZZ: disable check_for_ACE_Guard - int remove_handler_i (ACE_HANDLE handle, - ACE_Reactor_Mask mask, - ACE_Guard &repo_guard, - ACE_Event_Handler *eh = 0); - // FUZZ: enable check_for_ACE_Guard - - /// Temporarily remove the given handle from the "interest set." - int suspend_handler_i (ACE_HANDLE handle); - - /// Place the given handle that was temporarily removed from the - /// "interest set," i.e that was suspended, back in to the interest - /// set. The given handle will once again be polled for events. - int resume_handler_i (ACE_HANDLE handle); - - /// GET/SET/ADD/CLR the dispatch MASK "bit" bound with the handle - /// and mask. This internal helper method acquires no lock. - /** - * @return Old mask on success, -1 on error. - */ - int mask_ops_i (ACE_HANDLE handle, - ACE_Reactor_Mask mask, - int ops); - - /// Convert a reactor mask to its corresponding poll() event mask. - short reactor_mask_to_poll_event (ACE_Reactor_Mask mask); - -protected: - /// Has the reactor been initialized. - bool initialized_; - - /// The file descriptor associated with the open `/dev/poll' or - /// `/dev/epoll' device. - /** - * All interactions with the `/dev/poll' or `/dev/epoll' device are - * done through this file descriptor. - */ - ACE_HANDLE poll_fd_; - -#if defined (ACE_HAS_EVENT_POLL) - /// Event structure to be filled by epoll_wait. epoll_wait() only gets - /// one event at a time and we rely on it's internals for fairness. - /// If this struct's fd is ACE_INVALID_HANDLE, the rest is indeterminate. - /// If the fd is good, the event is one that's been retrieved by - /// epoll_wait() but not yet processed. - struct epoll_event event_; - -#else - /// The pollfd array that `/dev/poll' will feed its results to. - struct pollfd *dp_fds_; - - - /// Pointer to the next pollfd array element that contains the next - /// event to be dispatched. - struct pollfd *start_pfds_; - - /// The last element in the pollfd array plus one. - /** - * The loop that dispatches IO events stops when this->start_pfds == - * this->end_pfds_. - */ - struct pollfd *end_pfds_; -#endif /* ACE_HAS_EVENT_POLL */ - - /// Token serializing event waiter threads. - ACE_Dev_Poll_Reactor_Token token_; - - /// Adapter used to return internal lock to outside world. - ACE_Lock_Adapter lock_adapter_; - - /// This flag is used to keep track of whether we are actively handling - /// events or not. - sig_atomic_t deactivated_; - - /// Token used to protect manipulation of the handler repository. - /// No need to hold the waiter token to change the repo. - // ACE_DEV_POLL_TOKEN repo_token_; - ACE_SYNCH_MUTEX repo_lock_; - - /// The repository that contains all registered event handlers. - Handler_Repository handler_rep_; - - /// Defined as a pointer to allow overriding by derived classes... - ACE_Timer_Queue *timer_queue_; - - /// Keeps track of whether we should delete the timer queue (if we - /// didn't create it, then we don't delete it). - bool delete_timer_queue_; - - /// Handle signals without requiring global/static variables. - ACE_Sig_Handler *signal_handler_; - - /// Keeps track of whether we should delete the signal handler (if we - /// didn't create it, then we don't delete it). - bool delete_signal_handler_; - - /// Callback object that unblocks the if it's - /// sleeping. - ACE_Reactor_Notify *notify_handler_; - - /// Keeps track of whether we need to delete the notify handler (if - /// we didn't create it, then we don't delete it). - bool delete_notify_handler_; - - /// Flag that determines if signals are masked during event - /// dispatching. - /** - * If 0 then the Reactor will not mask the signals during the event - * dispatching. This is useful for applications that do not - * register any signal handlers and want to reduce the overhead - * introduce by the kernel level locks required to change the mask. - */ - int mask_signals_; - - /// Restart the handle_events event loop method automatically when - /// polling function in use (ioctl() in this case) is interrupted - /// via an EINTR signal. - bool restart_; - -protected: - - /** - * @class Token_Guard - * - * @brief A helper class that helps grabbing, releasing and waiting - * on tokens for a thread that needs access to the reactor's token. - */ - class ACE_Export Token_Guard - { - public: - /// Constructor that will grab the token for us - Token_Guard (ACE_Dev_Poll_Reactor_Token &token); - - /// Destructor. This will release the token if it hasn't been - /// released till this point - ~Token_Guard (void); - - /// Release the token .. - void release_token (void); - - /// Returns whether the thread that created this object owns the - /// token or not. - bool is_owner (void); - - /// A helper method that acquires the token 1) at a low priority, and - /// 2) wait quietly for the token, not waking another thread. This - /// is appropriate for cases where a thread wants to wait for and - /// dispatch an event, not causing an existing waiter to relinquish the - /// token. - int acquire_quietly (ACE_Time_Value *max_wait = 0); - - /// A helper method that acquires the token at a high priority, and - /// does wake the current token holder. - int acquire (ACE_Time_Value *max_wait = 0); - - private: - Token_Guard (void); - - private: - /// The Reactor token. - ACE_Dev_Poll_Reactor_Token &token_; - - /// Flag that indicate whether the thread that created this object - /// owns the token or not. A value of false indicates that this class - /// hasn't got the token (and hence the thread) and a value of true - /// vice-versa. - bool owner_; - }; -}; - - -/** - * @class ACE_Dev_Poll_Handler_Guard - * - * @brief Class used to make event handler reference count - * manipulation exception-safe. - * - * This class makes the reference count manipulation that occurs - * during an upcall exception-safe. Prior to dispatching the event - * handler, the reference count is increased. Once the upcall for the - * given event handler is complete, its reference count will be decreased. - */ -class ACE_Dev_Poll_Handler_Guard -{ -public: - /// Constructor - /** - * The constructor checks to see if @a eh is a reference-counted handler and - * remember that for later. If @a eh is reference counted, its reference - * count is incremented unless @a do_incr is false. - * @a do_incr should be false if the reference count was incremented - * independently of this guard, for example, on a notify handler since - * the reference count is incremented when the notify is queued. - */ - ACE_Dev_Poll_Handler_Guard (ACE_Event_Handler *eh, bool do_incr = true); - - /// Destructor - /** - * The destructor decrements the reference count on the event - * handler corresponding to the given handle. - */ - ~ACE_Dev_Poll_Handler_Guard (void); - - /// Release the event handler from this guard; when the destructor is - /// called, the handler's reference count will not be decremented. - void release (void); - -private: - /// The event handler being managed. - ACE_Event_Handler *eh_; - - /// true if eh_ is a reference-counted handler. - bool refcounted_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -# include "ace/Dev_Poll_Reactor.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* ACE_HAS_EVENT_POLL || ACE_HAS_DEV_POLL */ - -#include /**/ "ace/post.h" - -#endif /* ACE_DEV_POLL_REACTOR_H */ diff --git a/deps/acelite/ace/Dev_Poll_Reactor.inl b/deps/acelite/ace/Dev_Poll_Reactor.inl deleted file mode 100644 index 2b69631f2..000000000 --- a/deps/acelite/ace/Dev_Poll_Reactor.inl +++ /dev/null @@ -1,132 +0,0 @@ -// -*- C++ -*- -#include "ace/Log_Category.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Dev_Poll_Reactor::Event_Tuple::Event_Tuple (ACE_Event_Handler *eh, - ACE_Reactor_Mask m, - bool is_suspended, - bool is_controlled) - : event_handler (eh), - mask (m), - suspended (is_suspended), - controlled (is_controlled) -{ -} - -// --------------------------------------------------------------------- - -ACE_INLINE size_t -ACE_Dev_Poll_Reactor::Handler_Repository::size (void) const -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Handler_Repository::size"); - - return this->size_; -} - -ACE_INLINE size_t -ACE_Dev_Poll_Reactor::Handler_Repository::max_size (void) const -{ - ACE_TRACE ("ACE_Dev_Poll_Reactor::Handler_Repository::max_size"); - - return this->max_size_; -} - -// ----------------------------------------------------------------- - -ACE_INLINE -ACE_Dev_Poll_Handler_Guard::ACE_Dev_Poll_Handler_Guard - (ACE_Event_Handler *eh, - bool do_incr) - : eh_ (eh), - refcounted_ (false) -{ - if (eh == 0) - return; - - this->refcounted_ = - eh->reference_counting_policy ().value () == - ACE_Event_Handler::Reference_Counting_Policy::ENABLED; - - if (do_incr && this->refcounted_) - eh->add_reference (); -} - -ACE_INLINE -ACE_Dev_Poll_Handler_Guard::~ACE_Dev_Poll_Handler_Guard (void) -{ - if (this->refcounted_ && this->eh_ != 0) - this->eh_->remove_reference (); -} - -ACE_INLINE void -ACE_Dev_Poll_Handler_Guard::release (void) -{ - this->eh_ = 0; -} - -// --------------------------------------------------------------------- - -ACE_INLINE int -ACE_Dev_Poll_Reactor::upcall (ACE_Event_Handler *event_handler, - int (ACE_Event_Handler::*callback)(ACE_HANDLE), - ACE_HANDLE handle) -{ - // If the handler returns positive value (requesting a reactor - // callback) just call back as many times as the handler requests - // it. The handler is suspended internally and other threads are off - // handling other things. - int status = 0; - - do - { - status = (event_handler->*callback) (handle); - } - while (status > 0 && event_handler != this->notify_handler_); - - return status; -} - - -/************************************************************************/ -// Methods for ACE_Dev_Poll_Reactor::Token_Guard -/************************************************************************/ - -ACE_INLINE -ACE_Dev_Poll_Reactor::Token_Guard::Token_Guard (ACE_Dev_Poll_Reactor_Token &token) - - : token_ (token), - owner_ (false) -{ -} - -ACE_INLINE -ACE_Dev_Poll_Reactor::Token_Guard::~Token_Guard (void) -{ - if (this->owner_) - { - ACE_MT (this->token_.release ()); - this->owner_ = false; - } -} - -ACE_INLINE void -ACE_Dev_Poll_Reactor::Token_Guard::release_token (void) -{ - if (this->owner_) - { - ACE_MT (this->token_.release ()); - - // We are not the owner anymore.. - this->owner_ = false; - } -} - -ACE_INLINE bool -ACE_Dev_Poll_Reactor::Token_Guard::is_owner (void) -{ - return this->owner_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Dirent.cpp b/deps/acelite/ace/Dirent.cpp deleted file mode 100644 index 5f8bd074d..000000000 --- a/deps/acelite/ace/Dirent.cpp +++ /dev/null @@ -1,5 +0,0 @@ -#include "ace/Dirent.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Dirent.inl" -#endif /* __ACE_INLINE__ */ diff --git a/deps/acelite/ace/Dirent.h b/deps/acelite/ace/Dirent.h deleted file mode 100644 index 1981a3212..000000000 --- a/deps/acelite/ace/Dirent.h +++ /dev/null @@ -1,119 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Dirent.h - * - * Define a portable C++ interface to ACE_OS_Dirent directory-entry - * manipulation. - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_DIRENT_H -#define ACE_DIRENT_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/OS_NS_dirent.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Dirent - * - * @brief Define a portable C++ directory-entry iterator based on the POSIX API. - */ -class ACE_Export ACE_Dirent -{ -public: - /// Default constructor. - ACE_Dirent (void); - - /// Constructor calls @c opendir() - explicit ACE_Dirent (const ACE_TCHAR *dirname); - - /// Opens the directory named by filename and associates a directory - /// stream with it. - int open (const ACE_TCHAR *filename); - - /// Destructor calls @c closedir(). - ~ACE_Dirent (void); - - /// Closes the directory stream and frees the ACE_DIR structure. - void close (void); - - // = Iterator methods. - /** - * Returns a pointer to a structure representing the directory entry - * at the current position in the directory stream to which dirp - * refers, and positions the directory stream at the next entry, - * except on read-only filesystems. It returns a NULL pointer upon - * reaching the end of the directory stream, or upon detecting an - * invalid location in the directory. @c read() shall not return - * directory entries containing empty names. It is unspecified - * whether entries are returned for dot or dot-dot. The pointer - * returned by @c read() points to data that may be overwritten by - * another call to @c read() on the same directory stream. This - * data shall not be overwritten by another call to @c read() on a - * different directory stream. @c read() may buffer several - * directory entries per actual read operation; @c read() marks for - * update the st_atime field of the directory each time the - * directory is actually read. - */ - ACE_DIRENT *read (void); - - /** - * Has the equivalent functionality as @c read() except that an - * @a entry and @a result buffer must be supplied by the caller to - * store the result. - */ - int read (struct ACE_DIRENT *entry, - struct ACE_DIRENT **result); - - // = Manipulators. - /// Returns the current location associated with the directory - /// stream. - long tell (void); - - /** - * Sets the position of the next @c read() operation on the - * directory stream. The new position reverts to the position - * associated with the directory stream at the time the @c tell() - * operation that provides loc was performed. Values returned by - * @c tell() are good only for the lifetime of the ACE_DIR pointer from - * which they are derived. If the directory is closed and then - * reopened, the @c telldir() value may be invalidated due to - * undetected directory compaction. It is safe to use a previous - * @c telldir() value immediately after a call to @c opendir() and before - * any calls to readdir. - */ - void seek (long loc); - - /** - * Resets the position of the directory stream to the beginning of - * the directory. It also causes the directory stream to refer to - * the current state of the corresponding directory, as a call to - * @c opendir() would. - */ - void rewind (void); - -private: - /// Pointer to the directory stream. - ACE_DIR *dirp_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Dirent.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_DIRENT_H */ diff --git a/deps/acelite/ace/Dirent.inl b/deps/acelite/ace/Dirent.inl deleted file mode 100644 index 3e420f1cc..000000000 --- a/deps/acelite/ace/Dirent.inl +++ /dev/null @@ -1,96 +0,0 @@ -// -*- C++ -*- -#include "ace/Log_Category.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE int -ACE_Dirent::open (const ACE_TCHAR *dirname) -{ - // If the directory stream is already open, close it to prevent - // possible resource leaks. - - if (this->dirp_ != 0) - { - ACE_OS::closedir (this->dirp_); - this->dirp_ = 0; - } - - this->dirp_ = ACE_OS::opendir (dirname); - - if (this->dirp_ == 0) - return -1; - else - return 0; -} - -ACE_INLINE -ACE_Dirent::ACE_Dirent (void) - : dirp_ (0) -{ -} - -ACE_INLINE -ACE_Dirent::ACE_Dirent (const ACE_TCHAR *dirname) - : dirp_ (0) -{ - if (this->open (dirname) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Dirent::ACE_Dirent"))); -} - -ACE_INLINE -ACE_Dirent::~ACE_Dirent (void) -{ - if (this->dirp_ != 0) - ACE_OS::closedir (this->dirp_); -} - -ACE_INLINE ACE_DIRENT * -ACE_Dirent::read (void) -{ - return this->dirp_ ? ACE_OS::readdir (this->dirp_) : 0; -} - -ACE_INLINE int -ACE_Dirent::read (struct ACE_DIRENT *entry, - struct ACE_DIRENT **result) -{ - return this->dirp_ - ? ACE_OS::readdir_r (this->dirp_, entry, result) - : 0; -} - -ACE_INLINE void -ACE_Dirent::close (void) -{ - if (this->dirp_ != 0) - { - ACE_OS::closedir (this->dirp_); - - // Prevent double closure - this->dirp_ = 0; - } -} - -ACE_INLINE void -ACE_Dirent::rewind (void) -{ - if (this->dirp_) - ACE_OS::rewinddir (this->dirp_); -} - -ACE_INLINE void -ACE_Dirent::seek (long loc) -{ - if (this->dirp_) - ACE_OS::seekdir (this->dirp_, loc); -} - -ACE_INLINE long -ACE_Dirent::tell (void) -{ - return this->dirp_ ? ACE_OS::telldir (this->dirp_) : 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Dirent_Selector.cpp b/deps/acelite/ace/Dirent_Selector.cpp deleted file mode 100644 index f16d1da68..000000000 --- a/deps/acelite/ace/Dirent_Selector.cpp +++ /dev/null @@ -1,69 +0,0 @@ -#include "ace/Dirent_Selector.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Dirent_Selector.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/OS_NS_dirent.h" -#include "ace/OS_NS_stdlib.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Construction/Destruction - -ACE_Dirent_Selector::ACE_Dirent_Selector (void) - : namelist_ (0), - n_ (0) -{ -} - -ACE_Dirent_Selector::~ACE_Dirent_Selector (void) -{ - // Free up any allocated resources. - this->close(); -} - -int -ACE_Dirent_Selector::open (const ACE_TCHAR *dir, - ACE_SCANDIR_SELECTOR sel, - ACE_SCANDIR_COMPARATOR cmp) -{ - n_ = ACE_OS::scandir (dir, &this->namelist_, sel, cmp); - return n_; -} - -int -ACE_Dirent_Selector::close (void) -{ - for (--n_; n_ >= 0; --n_) - { -#if defined (ACE_LACKS_STRUCT_DIR) - // Only the lacking-struct-dir emulation allocates this. Native - // scandir includes d_name in the dirent struct itself. -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (this->namelist_[n_]->d_name); -#else - ACE_OS::free (this->namelist_[n_]->d_name); -#endif /* ACE_HAS_ALLOC_HOOKS */ -#endif -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (this->namelist_[n_]); -#else - ACE_OS::free (this->namelist_[n_]); -#endif /* ACE_HAS_ALLOC_HOOKS */ - } - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (this->namelist_); -#else - ACE_OS::free (this->namelist_); -#endif /* ACE_HAS_ALLOC_HOOKS */ - this->namelist_ = 0; - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Dirent_Selector.h b/deps/acelite/ace/Dirent_Selector.h deleted file mode 100644 index 5f3051cf1..000000000 --- a/deps/acelite/ace/Dirent_Selector.h +++ /dev/null @@ -1,73 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Dirent_Selector.h - * - * Define a portable C++ interface to the method. - * - * @author Rich Newman - */ -//============================================================================= - -#ifndef ACE_DIRENT_SELECTOR_H -#define ACE_DIRENT_SELECTOR_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/OS_NS_dirent.h" /* Need ACE_SCANDIR_SELECTOR, COMPARATOR */ -#include "ace/os_include/os_dirent.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Dirent_Selector - * - * @brief Define a portable C++ directory-entry iterator based on the - * POSIX scandir API. - */ -class ACE_Export ACE_Dirent_Selector -{ -public: - /// Constructor - ACE_Dirent_Selector (void); - - /// Destructor. - virtual ~ACE_Dirent_Selector (void); - - /// Return the length of the list of matching directory entries. - int length (void) const; - - /// Return the entry at @a index. - ACE_DIRENT *operator[] (const int index) const; - - /// Free up resources. - int close (void); - - /// Open the directory @a dir and populate the current list of names with - /// directory entries that match the @a selector and @a comparator. - int open (const ACE_TCHAR *dir, - ACE_SCANDIR_SELECTOR selector = 0, - ACE_SCANDIR_COMPARATOR comparator = 0); - -protected: - /// Ptr to the namelist array. - ACE_DIRENT **namelist_; - - /// Number of entries in the array. - int n_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Dirent_Selector.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_DIRENT_SELECTOR_H */ diff --git a/deps/acelite/ace/Dirent_Selector.inl b/deps/acelite/ace/Dirent_Selector.inl deleted file mode 100644 index 27651569b..000000000 --- a/deps/acelite/ace/Dirent_Selector.inl +++ /dev/null @@ -1,16 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE int -ACE_Dirent_Selector::length (void) const -{ - return n_; -} - -ACE_INLINE ACE_DIRENT * -ACE_Dirent_Selector::operator[] (const int n) const -{ - return this->namelist_[n]; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Dump.cpp b/deps/acelite/ace/Dump.cpp deleted file mode 100644 index 576417e81..000000000 --- a/deps/acelite/ace/Dump.cpp +++ /dev/null @@ -1,143 +0,0 @@ -#include "ace/Dump.h" -#include "ace/Guard_T.h" -#include "ace/Thread_Mutex.h" -#include "ace/Object_Manager.h" -#include "ace/Log_Category.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Implementations (very simple for now...) - -ACE_Dumpable::~ACE_Dumpable (void) -{ - ACE_TRACE ("ACE_Dumpable::~ACE_Dumpable"); -} - -ACE_Dumpable::ACE_Dumpable (const void *this_ptr) - : this_ (this_ptr) -{ - ACE_TRACE ("ACE_Dumpable::ACE_Dumpable"); -} - -ACE_Dumpable_Ptr::ACE_Dumpable_Ptr (const ACE_Dumpable *dumper) - : dumper_ (dumper) -{ - ACE_TRACE ("ACE_Dumpable_Ptr::ACE_Dumpable_Ptr"); -} - -const ACE_Dumpable * -ACE_Dumpable_Ptr::operator->() const -{ - ACE_TRACE ("ACE_Dumpable_Ptr::operator->"); - return this->dumper_; -} - -void -ACE_Dumpable_Ptr::operator= (const ACE_Dumpable *dumper) const -{ - ACE_TRACE ("ACE_Dumpable_Ptr::operator="); - if (this->dumper_ != dumper) - { - delete const_cast (this->dumper_); - (const_cast (this))->dumper_ = dumper; - } -} - -ACE_ODB::ACE_ODB (void) - // Let the Tuple default constructor initialize object_table_ - : current_size_ (0) -{ - ACE_TRACE ("ACE_ODB::ACE_ODB"); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_ODB) - -ACE_ODB * -ACE_ODB::instance (void) -{ - ACE_TRACE ("ACE_ODB::instance"); - - if (ACE_ODB::instance_ == 0) - { - ACE_MT (ACE_Thread_Mutex *lock = - ACE_Managed_Object::get_preallocated_object - (ACE_Object_Manager::ACE_DUMP_LOCK); - ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, *lock, 0)); - - if (ACE_ODB::instance_ == 0) - ACE_NEW_RETURN (ACE_ODB::instance_, - ACE_ODB, - 0); - } - - return ACE_ODB::instance_; -} - -void -ACE_ODB::dump_objects (void) -{ - ACE_TRACE ("ACE_ODB::dump_objects"); - for (int i = 0; i < this->current_size_; i++) - { - if (this->object_table_[i].this_ != 0) - // Dump the state of the object. - this->object_table_[i].dumper_->dump (); - } -} - -// This method registers a new . It detects -// duplicates and simply overwrites them. - -void -ACE_ODB::register_object (const ACE_Dumpable *dumper) -{ - ACE_TRACE ("ACE_ODB::register_object"); - int i; - int slot = 0; - - for (i = 0; i < this->current_size_; i++) - { - if (this->object_table_[i].this_ == 0) - slot = i; - else if (this->object_table_[i].this_ == dumper->this_) - { - slot = i; - break; - } - } - - if (i == this->current_size_) - { - slot = this->current_size_++; - ACE_ASSERT (this->current_size_ < ACE_ODB::MAX_TABLE_SIZE); - } - this->object_table_[slot].this_ = dumper->this_; - this->object_table_[slot].dumper_ = dumper; -} - -void -ACE_ODB::remove_object (const void *this_ptr) -{ - ACE_TRACE ("ACE_ODB::remove_object"); - int i; - - for (i = 0; i < this->current_size_; i++) - { - if (this->object_table_[i].this_ == this_ptr) - break; - } - - if (i < this->current_size_) - { - this->object_table_[i].this_ = 0; - this->object_table_[i].dumper_ = 0; - } -} - -ACE_ODB *ACE_ODB::instance_ = 0; - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Dump.h b/deps/acelite/ace/Dump.h deleted file mode 100644 index 09eafd1a6..000000000 --- a/deps/acelite/ace/Dump.h +++ /dev/null @@ -1,170 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Dump.h - * - * A prototype mechanism that allow all ACE objects to be registered - * with a central in-memory "database" that can dump the state of all - * live ACE objects (e.g., from within a debugger). - * - * The macros which allow easy registration and removal of objects to be - * dumped (ACE_REGISTER_OBJECT and ACE_REMOVE_OBJECT) are turned into - * no-ops by compiling with the ACE_NDEBUG macro defined. This allows - * usage to be removed in "release mode" builds without changing code. - * - * There are several interesting aspects to this design: - * - * 1. It uses the External Polymorphism pattern to avoid having to - * derive all ACE classes from a common base class that has virtual - * methods (this is crucial to avoid unnecessary overhead). In - * addition, there is no additional space added to ACE objects - * (this is crucial to maintain binary layout compatibility). - * - * 2. This mechanism can be conditionally compiled in order to - * completely disable this feature entirely. Moreover, by - * using macros there are relatively few changes to ACE code. - * - * 3. This mechanism copes with single-inheritance hierarchies of - * dumpable classes. In such cases we typically want only one - * dump, corresponding to the most derived instance. Thanks to - * Christian Millour (chris@etca.fr) for illustrating how to do - * this. Note, however, that this scheme doesn't generalize to - * work with multiple-inheritance or virtual base classes. - * - * Future work includes: - * - * 1. Using a dynamic object table rather than a static table - * - * 2. Adding support to allow particular classes of objects to - * be selectively dumped. - * - * @author Doug Schmidt - */ -//============================================================================= - - -#ifndef ACE_DUMP_H -#define ACE_DUMP_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Dumpable - * - * @brief Base class that defines a uniform interface for all object - * dumping. - */ -class ACE_Export ACE_Dumpable -{ -public: - friend class ACE_ODB; - friend class ACE_Dumpable_Ptr; - - /// Constructor. - ACE_Dumpable (const void *); - - /// This pure virtual method must be filled in by a subclass. - virtual void dump (void) const = 0; - -protected: - virtual ~ACE_Dumpable (void); - -private: - /// Pointer to the object that is being stored. - const void *this_; -}; - -/** - * @class ACE_Dumpable_Ptr - * - * @brief A smart pointer stored in the in-memory object database - * ACE_ODB. The pointee (if any) is deleted when reassigned. - */ -class ACE_Export ACE_Dumpable_Ptr -{ -public: - ACE_Dumpable_Ptr (const ACE_Dumpable *dumper = 0); - const ACE_Dumpable *operator->() const; - void operator= (const ACE_Dumpable *dumper) const; - -private: - /// "Real" pointer to the underlying abstract base class - /// pointer that does the real work. - const ACE_Dumpable *dumper_; -}; - -/** - * @class ACE_ODB - * - * @brief This is the object database (ODB) that keeps track of all - * live ACE objects. - */ -class ACE_Export ACE_ODB -{ -public: - /// @todo This is clearly inadequate and should be dynamic... - enum {MAX_TABLE_SIZE = 100000}; - - /// Iterates through the entire set of registered objects and - /// dumps their state. - void dump_objects (void); - - /// Add the tuple to the list of registered ACE objects. - void register_object (const ACE_Dumpable *dumper); - - /// Use to locate and remove the associated from the - /// list of registered ACE objects. - void remove_object (const void *this_); - - /// Interface to the Singleton instance of the object database. - static ACE_ODB *instance (void); - - ACE_ALLOC_HOOK_DECLARE; - -private: - ACE_ODB (void); // Ensure we have a Singleton... - - struct Tuple - { - /// Pointer to the object that is registered. - const void *this_; - - /// Smart pointer to the ACE_Dumpable object associated with this_. - /// This uses an ACE_Dumpable_Ptr, instead of a bare pointer, to - /// cope with hierarchies of dumpable classes. In such cases we - /// typically want only one dump, corresponding to the most derived - /// instance. To achieve this, the handle registered for the - /// subobject corresponding to the base class is destroyed (hence - /// on destruction of the subobject its handle won't exist anymore - /// and we'll have to check for that). - const ACE_Dumpable_Ptr dumper_; - - Tuple (void) : this_ (0), dumper_(0) {} - }; - - /// Singleton instance of this class. - static ACE_ODB *instance_; - - /// The current implementation is very simple-minded and will be - /// changed to be dynamic. - Tuple object_table_[ACE_ODB::MAX_TABLE_SIZE]; - - /// Current size of . - int current_size_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -// Include the templates classes at this point. -#include "ace/Dump_T.h" - -#include /**/ "ace/post.h" -#endif /* ACE_DUMP_H */ diff --git a/deps/acelite/ace/Dump_T.cpp b/deps/acelite/ace/Dump_T.cpp deleted file mode 100644 index fc0833a9e..000000000 --- a/deps/acelite/ace/Dump_T.cpp +++ /dev/null @@ -1,45 +0,0 @@ -// Dump_T.cpp -#ifndef ACE_DUMP_T_CPP -#define ACE_DUMP_T_CPP - -#include "ace/Dump_T.h" -#include "ace/Global_Macros.h" -#include "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Dumpable_Adapter::~ACE_Dumpable_Adapter (void) -{ - ACE_TRACE ("ACE_Dumpable_Adapter::~ACE_Dumpable_Adapter"); -} - -template -ACE_Dumpable_Adapter::ACE_Dumpable_Adapter (const Concrete *t) - : ACE_Dumpable ((const void *) t), this_ (t) -{ - ACE_TRACE ("ACE_Dumpable_Adapter::ACE_Dumpable_Adapter"); -} - -template Concrete * -ACE_Dumpable_Adapter::operator->() const -{ - return (Concrete *) this->this_; -} - -template void -ACE_Dumpable_Adapter::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Dumpable_Adapter::dump"); - this->this_->dump (); -#endif /* ACE_HAS_DUMP */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_DUMP_T_CPP */ diff --git a/deps/acelite/ace/Dump_T.h b/deps/acelite/ace/Dump_T.h deleted file mode 100644 index d20fae850..000000000 --- a/deps/acelite/ace/Dump_T.h +++ /dev/null @@ -1,80 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Dump_T.h - * - * @author Doug Schmidt - */ -//============================================================================= - - -#ifndef ACE_DUMP_T_H -#define ACE_DUMP_T_H -#include /**/ "ace/pre.h" - -#include "ace/Dump.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Dumpable_Adapter - * - * @brief - * This class inherits the interface of the abstract ACE_Dumpable - * class and is instantiated with the implementation of the - * concrete component class . - * - * This design is similar to the Adapter and Decorator patterns - * from the ``Gang of Four'' book. Note that - * need not inherit from a common class since ACE_Dumpable - * provides the uniform virtual interface! - */ -template -class ACE_Dumpable_Adapter : public ACE_Dumpable -{ -public: - ACE_Dumpable_Adapter (const Concrete *t); - ~ACE_Dumpable_Adapter (void); - - /// Concrete dump method (simply delegates to the dump() method of - /// ). - virtual void dump (void) const; - - /// Delegate to methods in the Concrete class. - Concrete *operator->() const; - -private: - /// Pointer to @c this of . - const Concrete *this_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -// Some useful macros for conditionally compiling this feature... -#if defined (ACE_NDEBUG) -#define ACE_REGISTER_OBJECT(CLASS) -#define ACE_REMOVE_OBJECT -#else -#define ACE_REGISTER_OBJECT(CLASS) \ - ACE_ODB::instance ()->register_object \ - (new ACE_Dumpable_Adapter (this)); -#define ACE_REMOVE_OBJECT \ - ACE_ODB::instance ()->remove_object \ - ((void *) this); -#endif /* ACE_NDEBUG */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Dump_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Dump_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_DUMP_T_H */ diff --git a/deps/acelite/ace/Dynamic.cpp b/deps/acelite/ace/Dynamic.cpp deleted file mode 100644 index 469d67e40..000000000 --- a/deps/acelite/ace/Dynamic.cpp +++ /dev/null @@ -1,32 +0,0 @@ -#include "ace/Dynamic.h" -#include "ace/Singleton.h" -#include "ace/TSS_T.h" -#include "ace/Synch_Traits.h" -#include "ace/Null_Mutex.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Dynamic.inl" -#endif /* __ACE_INLINE__ */ - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Dynamic::ACE_Dynamic (void) - : is_dynamic_ (false) -{ - ACE_TRACE ("ACE_Dynamic::ACE_Dynamic"); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Dynamic) - -/* static */ ACE_Dynamic * -ACE_Dynamic::instance (void) -{ - return ACE_TSS_Singleton::instance (); -} - -ACE_SINGLETON_TEMPLATE_INSTANTIATE(ACE_TSS_Singleton, ACE_Dynamic, ACE_Null_Mutex); - - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Dynamic.h b/deps/acelite/ace/Dynamic.h deleted file mode 100644 index 202d000dc..000000000 --- a/deps/acelite/ace/Dynamic.h +++ /dev/null @@ -1,74 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Dynamic.h - * - * @author Doug Schmidt - * @author Irfan Pyarali. - */ -//========================================================================== - -#ifndef ACE_DYNAMIC_H -#define ACE_DYNAMIC_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Dynamic - * - * @brief Checks to see if an object was dynamically allocated. - * - * This class holds the pointer in a thread-safe manner between - * the call to operator new and the call to the constructor. - */ -class ACE_Export ACE_Dynamic -{ -public: - /// Constructor. - ACE_Dynamic (void); - - /// Destructor. - ~ACE_Dynamic (void); - - /** - * Sets a flag that indicates that the object was dynamically - * created. This method is usually called in operator new and then - * checked and reset in the constructor. - */ - void set (void); - - /// @c true if we were allocated dynamically, else @c false. - bool is_dynamic (void); - - /// Resets state flag. - void reset (void); - - static ACE_Dynamic *instance (void); - - ACE_ALLOC_HOOK_DECLARE; - -private: - /** - * Flag that indicates that the object was dynamically created. This - * method is usually called in operator new and then checked and - * reset in the constructor. - */ - bool is_dynamic_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Dynamic.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_DYNAMIC_H */ diff --git a/deps/acelite/ace/Dynamic.inl b/deps/acelite/ace/Dynamic.inl deleted file mode 100644 index 795f33d2e..000000000 --- a/deps/acelite/ace/Dynamic.inl +++ /dev/null @@ -1,31 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Dynamic::~ACE_Dynamic (void) -{ - // ACE_TRACE ("ACE_Dynamic::~ACE_Dynamic"); -} - -ACE_INLINE void -ACE_Dynamic::set (void) -{ - // ACE_TRACE ("ACE_Dynamic::set"); - this->is_dynamic_ = true; -} - -ACE_INLINE bool -ACE_Dynamic::is_dynamic (void) -{ - // ACE_TRACE ("ACE_Dynamic::is_dynamic"); - return this->is_dynamic_; -} - -ACE_INLINE void -ACE_Dynamic::reset (void) -{ - // ACE_TRACE ("ACE_Dynamic::reset"); - this->is_dynamic_ = false; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Dynamic_Message_Strategy.cpp b/deps/acelite/ace/Dynamic_Message_Strategy.cpp deleted file mode 100644 index 35802fdbf..000000000 --- a/deps/acelite/ace/Dynamic_Message_Strategy.cpp +++ /dev/null @@ -1,201 +0,0 @@ -#include "ace/Dynamic_Message_Strategy.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Dynamic_Message_Strategy.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Guard_T.h" -#include "ace/Log_Category.h" -#include "ace/Malloc_Base.h" -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// ctor - -ACE_Dynamic_Message_Strategy::ACE_Dynamic_Message_Strategy (unsigned long static_bit_field_mask, - unsigned long static_bit_field_shift, - unsigned long dynamic_priority_max, - unsigned long dynamic_priority_offset) - : static_bit_field_mask_ (static_bit_field_mask), - static_bit_field_shift_ (static_bit_field_shift), - dynamic_priority_max_ (dynamic_priority_max), - dynamic_priority_offset_ (dynamic_priority_offset), - max_late_ (0, dynamic_priority_offset - 1), - min_pending_ (0, dynamic_priority_offset), - pending_shift_ (0, dynamic_priority_max) -{ -} - -// dtor - -ACE_Dynamic_Message_Strategy::~ACE_Dynamic_Message_Strategy (void) -{ -} - -ACE_Dynamic_Message_Strategy::Priority_Status -ACE_Dynamic_Message_Strategy::priority_status (ACE_Message_Block & mb, - const ACE_Time_Value & tv) -{ - // default the message to have pending priority status - Priority_Status status = ACE_Dynamic_Message_Strategy::PENDING; - - // start with the passed absolute time as the message's priority, then - // call the polymorphic hook method to (at least partially) convert - // the absolute time and message attributes into the message's priority - ACE_Time_Value priority (tv); - convert_priority (priority, mb); - - // if the priority is negative, the message is pending - if (priority < ACE_Time_Value::zero) - { - // priority for pending messages must be shifted - // upward above the late priority range - priority += pending_shift_; - if (priority < min_pending_) - priority = min_pending_; - } - // otherwise, if the priority is greater than the maximum late - // priority value that can be represented, it is beyond late - else if (priority > max_late_) - { - // all messages that are beyond late are assigned lowest priority (zero) - mb.msg_priority (0); - return ACE_Dynamic_Message_Strategy::BEYOND_LATE; - } - // otherwise, the message is late, but its priority is correct - else - status = ACE_Dynamic_Message_Strategy::LATE; - - // use (fast) bitwise operators to isolate and replace - // the dynamic portion of the message's priority - mb.msg_priority((mb.msg_priority() & static_bit_field_mask_) | - ((priority.usec () + - ACE_ONE_SECOND_IN_USECS * (suseconds_t)(priority.sec())) << - static_bit_field_shift_)); - - // returns the priority status of the message - return status; -} - - -// Dump the state of the strategy. - -void -ACE_Dynamic_Message_Strategy::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Dynamic_Message_Strategy::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("static_bit_field_mask_ = %u\n") - ACE_TEXT ("static_bit_field_shift_ = %u\n") - ACE_TEXT ("dynamic_priority_max_ = %u\n") - ACE_TEXT ("dynamic_priority_offset_ = %u\n") - ACE_TEXT ("max_late_ = [%d sec, %d usec]\n") - ACE_TEXT ("min_pending_ = [%d sec, %d usec]\n") - ACE_TEXT ("pending_shift_ = [%d sec, %d usec]\n"), - this->static_bit_field_mask_, - this->static_bit_field_shift_, - this->dynamic_priority_max_, - this->dynamic_priority_offset_, - this->max_late_.sec (), - this->max_late_.usec (), - this->min_pending_.sec (), - this->min_pending_.usec (), - this->pending_shift_.sec (), - this->pending_shift_.usec ())); - - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Deadline_Message_Strategy::ACE_Deadline_Message_Strategy (unsigned long static_bit_field_mask, - unsigned long static_bit_field_shift, - unsigned long dynamic_priority_max, - unsigned long dynamic_priority_offset) - : ACE_Dynamic_Message_Strategy (static_bit_field_mask, - static_bit_field_shift, - dynamic_priority_max, - dynamic_priority_offset) -{ -} - -ACE_Deadline_Message_Strategy::~ACE_Deadline_Message_Strategy (void) -{ -} - -void -ACE_Deadline_Message_Strategy::convert_priority (ACE_Time_Value & priority, - const ACE_Message_Block & mb) -{ - // Convert absolute time passed in tv to negative time - // to deadline of mb with respect to that absolute time. - priority -= mb.msg_deadline_time (); -} - // dynamic priority conversion function based on time to deadline - -void -ACE_Deadline_Message_Strategy::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Deadline_Message_Strategy::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Dynamic_Message_Strategy base class:\n"))); - this->ACE_Dynamic_Message_Strategy::dump (); - - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nderived class: ACE_Deadline_Message_Strategy\n"))); - - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Laxity_Message_Strategy::ACE_Laxity_Message_Strategy (unsigned long static_bit_field_mask, - unsigned long static_bit_field_shift, - unsigned long dynamic_priority_max, - unsigned long dynamic_priority_offset) - : ACE_Dynamic_Message_Strategy (static_bit_field_mask, - static_bit_field_shift, - dynamic_priority_max, - dynamic_priority_offset) -{ -} - -ACE_Laxity_Message_Strategy::~ACE_Laxity_Message_Strategy (void) -{ -} - -void -ACE_Laxity_Message_Strategy::convert_priority (ACE_Time_Value & priority, - const ACE_Message_Block & mb) -{ - // Convert absolute time passed in tv to negative - // laxity of mb with respect to that absolute time. - priority += mb.msg_execution_time (); - priority -= mb.msg_deadline_time (); -} - // dynamic priority conversion function based on laxity - -void -ACE_Laxity_Message_Strategy::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Laxity_Message_Strategy::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Dynamic_Message_Strategy base class:\n"))); - this->ACE_Dynamic_Message_Strategy::dump (); - - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nderived class: ACE_Laxity_Message_Strategy\n"))); - - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - // Dump the state of the strategy. - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Dynamic_Message_Strategy.h b/deps/acelite/ace/Dynamic_Message_Strategy.h deleted file mode 100644 index 5d24157ca..000000000 --- a/deps/acelite/ace/Dynamic_Message_Strategy.h +++ /dev/null @@ -1,212 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Dynamic_Message_Strategy.h - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_DYNAMIC_MESSAGE_STRATEGY_H -#define ACE_DYNAMIC_MESSAGE_STRATEGY_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-lite.h" -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Message_Block.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Dynamic_Message_Strategy - * - * @brief An abstract base class which provides dynamic priority - * evaluation methods for use by the ACE_Dynamic_Message_Queue - * class or any other class which needs to manage the priorities - * of a collection of ACE_Message_Blocks dynamically. - * - * Methods for deadline and laxity based priority evaluation are - * provided. These methods assume a specific partitioning of - * the message priority number into a higher order dynamic bit - * field and a lower order static priority bit field. The - * default partitioning assumes an unsigned dynamic message - * priority field of 22 bits and an unsigned static message - * priority field of 10 bits. This corresponds to the initial - * values of the static class members. To provide a different - * partitioning, assign a different set of values to the static - * class members before using the static member functions. - */ -class ACE_Export ACE_Dynamic_Message_Strategy -{ -public: - /// Message priority status - /// Values are defined as bit flags so that status combinations may - /// be specified easily. - enum Priority_Status - { - /// Message can still make its deadline - PENDING = 0x01, - /// Message cannot make its deadline - LATE = 0x02, - /// Message is so late its priority is undefined - BEYOND_LATE = 0x04, - /// Mask to match any priority status - ANY_STATUS = 0x07 - }; - - /// Constructor. - ACE_Dynamic_Message_Strategy (unsigned long static_bit_field_mask, - unsigned long static_bit_field_shift, - unsigned long dynamic_priority_max, - unsigned long dynamic_priority_offset); - - /// Virtual destructor. - virtual ~ACE_Dynamic_Message_Strategy (void); - - /// Updates the message's priority and returns its priority status. - Priority_Status priority_status (ACE_Message_Block &mb, - const ACE_Time_Value &tv); - - /// Get static bit field mask. - unsigned long static_bit_field_mask (void) const; - - /// Set static bit field mask. - void static_bit_field_mask (unsigned long); - - /// Get left shift value to make room for static bit field. - unsigned long static_bit_field_shift (void) const; - - /// Set left shift value to make room for static bit field. - void static_bit_field_shift (unsigned long); - - /// Get maximum supported priority value. - unsigned long dynamic_priority_max (void) const; - - /// Set maximum supported priority value. - void dynamic_priority_max (unsigned long); - - /// Get offset to boundary between signed range and unsigned range. - unsigned long dynamic_priority_offset (void) const; - - /// Set offset to boundary between signed range and unsigned range. - void dynamic_priority_offset (unsigned long); - - /// Dump the state of the strategy. - virtual void dump (void) const; - -protected: - /// Hook method for dynamic priority conversion. - virtual void convert_priority (ACE_Time_Value &priority, - const ACE_Message_Block &mb) = 0; - - /// This is a bit mask with all ones in the static bit field. - unsigned long static_bit_field_mask_; - - /** - * This is a left shift value to make room for static bit field: - * this value should be the logarithm base 2 of - * (static_bit_field_mask_ + 1). - */ - unsigned long static_bit_field_shift_; - - /// Maximum supported priority value. - unsigned long dynamic_priority_max_; - - /// Offset to boundary between signed range and unsigned range. - unsigned long dynamic_priority_offset_; - - /// Maximum late time value that can be represented. - ACE_Time_Value max_late_; - - /// Minimum pending time value that can be represented. - ACE_Time_Value min_pending_; - - /// Time value by which to shift pending priority. - ACE_Time_Value pending_shift_; -}; - -/** - * @class ACE_Deadline_Message_Strategy - * - * @brief Deadline based message priority strategy. - * - * Assigns dynamic message priority according to time to deadline. The - * message priority is divided into high and low order bit fields. The - * high order bit field is used for dynamic message priority, which is - * updated whenever the convert_priority() method is called. The - * low order bit field is used for static message priority and is left - * unchanged. The partitioning of the priority value into high and low - * order bit fields is done according to the arguments passed to the - * strategy object's constructor. - */ -class ACE_Export ACE_Deadline_Message_Strategy : public ACE_Dynamic_Message_Strategy -{ -public: - /// Constructor with all arguments defaulted. - ACE_Deadline_Message_Strategy (unsigned long static_bit_field_mask = 0x3FFUL, // 2^(10) - 1 - unsigned long static_bit_field_shift = 10, // 10 low order bits - unsigned long dynamic_priority_max = 0x3FFFFFUL, // 2^(22)-1 - unsigned long dynamic_priority_offset = 0x200000UL); // 2^(22-1) - - /// Virtual destructor. - virtual ~ACE_Deadline_Message_Strategy (void); - - /// Dynamic priority conversion function based on time to deadline. - virtual void convert_priority (ACE_Time_Value &priority, - const ACE_Message_Block &mb); - - /// Dump the state of the strategy. - virtual void dump (void) const; -}; - -/** - * @class ACE_Laxity_Message_Strategy - * - * @brief Laxity based message priority strategy. - * - * Assigns dynamic message priority according to laxity (time to - * deadline minus worst case execution time). The message priority is - * divided into high and low order bit fields. The high order - * bit field is used for dynamic message priority, which is - * updated whenever the convert_priority() method is called. The - * low order bit field is used for static message priority and is left - * unchanged. The partitioning of the priority value into high and low - * order bit fields is done according to the arguments passed to the - * strategy object's constructor. - */ -class ACE_Export ACE_Laxity_Message_Strategy : public ACE_Dynamic_Message_Strategy -{ -public: - /// Ctor, with all arguments defaulted. - ACE_Laxity_Message_Strategy (unsigned long static_bit_field_mask = 0x3FFUL, // 2^(10) - 1 - unsigned long static_bit_field_shift = 10, // 10 low order bits - unsigned long dynamic_priority_max = 0x3FFFFFUL, // 2^(22)-1 - unsigned long dynamic_priority_offset = 0x200000UL); // 2^(22-1) - - /// virtual dtor. - virtual ~ACE_Laxity_Message_Strategy (void); - - /// Dynamic priority conversion function based on laxity. - virtual void convert_priority (ACE_Time_Value &priority, - const ACE_Message_Block &mb); - - /// Dump the state of the strategy. - virtual void dump (void) const; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Dynamic_Message_Strategy.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* ACE_DYNAMIC_MESSAGE_STRATEGY_H */ diff --git a/deps/acelite/ace/Dynamic_Message_Strategy.inl b/deps/acelite/ace/Dynamic_Message_Strategy.inl deleted file mode 100644 index 675e0f1e4..000000000 --- a/deps/acelite/ace/Dynamic_Message_Strategy.inl +++ /dev/null @@ -1,72 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE unsigned long -ACE_Dynamic_Message_Strategy::static_bit_field_mask (void) const -{ - return static_bit_field_mask_; -} - // get static bit field mask - -ACE_INLINE void -ACE_Dynamic_Message_Strategy::static_bit_field_mask (unsigned long ul) -{ - static_bit_field_mask_ = ul; -} - // set static bit field mask - -ACE_INLINE unsigned long -ACE_Dynamic_Message_Strategy::static_bit_field_shift (void) const -{ - return static_bit_field_shift_; -} - // get left shift value to make room for static bit field - -ACE_INLINE void -ACE_Dynamic_Message_Strategy::static_bit_field_shift (unsigned long ul) -{ - static_bit_field_shift_ = ul; -} - // set left shift value to make room for static bit field - -ACE_INLINE unsigned long -ACE_Dynamic_Message_Strategy::dynamic_priority_max (void) const -{ - return dynamic_priority_max_; -} - // get maximum supported priority value - -ACE_INLINE void -ACE_Dynamic_Message_Strategy::dynamic_priority_max (unsigned long ul) -{ - // pending_shift_ depends on dynamic_priority_max_: for performance - // reasons, the value in pending_shift_ is (re)calculated only when - // dynamic_priority_max_ is initialized or changes, and is stored - // as a class member rather than being a derived value. - dynamic_priority_max_ = ul; - pending_shift_ = ACE_Time_Value (0, ul); -} - // set maximum supported priority value - -ACE_INLINE unsigned long -ACE_Dynamic_Message_Strategy::dynamic_priority_offset (void) const -{ - return dynamic_priority_offset_; -} - // get offset for boundary between signed range and unsigned range - -ACE_INLINE void -ACE_Dynamic_Message_Strategy::dynamic_priority_offset (unsigned long ul) -{ - // max_late_ and min_pending_ depend on dynamic_priority_offset_: - // for performance reasons, the values in max_late_ and min_pending_ - // are (re)calculated only when dynamic_priority_offset_ is - // initialized or changes, and are stored as a class member rather - // than being derived each time one of their values is needed. - dynamic_priority_offset_ = ul; - max_late_ = ACE_Time_Value (0, ul - 1); - min_pending_ = ACE_Time_Value (0, ul); -} - // set offset for boundary between signed range and unsigned range - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Dynamic_Service.cpp b/deps/acelite/ace/Dynamic_Service.cpp deleted file mode 100644 index 8bf6871d1..000000000 --- a/deps/acelite/ace/Dynamic_Service.cpp +++ /dev/null @@ -1,61 +0,0 @@ -#ifndef ACE_DYNAMIC_SERVICE_CPP -#define ACE_DYNAMIC_SERVICE_CPP - -#include "ace/Dynamic_Service.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Service_Object.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Dynamic_Service.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - - -template TYPE * -ACE_Dynamic_Service::instance (const ACE_TCHAR *name) -{ - ACE_Service_Object * svc_obj = - static_cast - (ACE_Dynamic_Service_Base::instance (name,false)); - return dynamic_cast (svc_obj); -} - -template TYPE * -ACE_Dynamic_Service::instance (const ACE_TCHAR *name, - bool no_global) -{ - ACE_Service_Object * svc_obj = - static_cast - (ACE_Dynamic_Service_Base::instance (name, no_global)); - return dynamic_cast (svc_obj); -} - -template TYPE * -ACE_Dynamic_Service::instance (const ACE_Service_Gestalt* conf, - const ACE_TCHAR *name) -{ - ACE_Service_Object * svc_obj = - static_cast - (ACE_Dynamic_Service_Base::instance (conf, name, false)); - return dynamic_cast (svc_obj); -} - -template TYPE * -ACE_Dynamic_Service::instance (const ACE_Service_Gestalt* conf, - const ACE_TCHAR *name, - bool no_global) -{ - ACE_Service_Object * svc_obj = - static_cast - (ACE_Dynamic_Service_Base::instance (conf, name, no_global)); - return dynamic_cast (svc_obj); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_DYNAMIC_SERVICE_CPP */ diff --git a/deps/acelite/ace/Dynamic_Service.h b/deps/acelite/ace/Dynamic_Service.h deleted file mode 100644 index 84b45b0bd..000000000 --- a/deps/acelite/ace/Dynamic_Service.h +++ /dev/null @@ -1,87 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Dynamic_Service.h - * - * @author Prashant Jain - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_DYNAMIC_SERVICE_H -#define ACE_DYNAMIC_SERVICE_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" -#include "ace/Global_Macros.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Dynamic_Service_Base.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Service_Object; - -/** - * @class ACE_Dynamic_Service - * - * @brief Provides a general interface to retrieve arbitrary objects - * from the ACE service repository. - * - * Uses "name" for lookup in the ACE service repository. Obtains - * the object and returns it as the appropriate type. - */ -template -class ACE_Dynamic_Service : public ACE_Dynamic_Service_Base -{ -public: - /// Return instance using @a name to search the Service_Repository. - static TYPE* instance (const ACE_TCHAR *name); - static TYPE* instance (const ACE_TCHAR *name, bool no_global); - - static TYPE* instance (const ACE_Service_Gestalt* repo, - const ACE_TCHAR *name); - static TYPE* instance (const ACE_Service_Gestalt* repo, - const ACE_TCHAR *name, bool no_global); - -#if defined (ACE_USES_WCHAR) - - /// Return instance using @a name to search the Service_Repository. - static TYPE* instance (const ACE_ANTI_TCHAR *name); - - static TYPE* instance (const ACE_ANTI_TCHAR *name, bool no_global); - - static TYPE* instance (const ACE_Service_Gestalt* repo, - const ACE_ANTI_TCHAR *name); - static TYPE* instance (const ACE_Service_Gestalt* repo, - const ACE_ANTI_TCHAR *name, bool no_global); -#endif // ACE_USES_WCHAR - -private: - ACE_UNIMPLEMENTED_FUNC (ACE_Dynamic_Service ()) - ACE_UNIMPLEMENTED_FUNC (ACE_Dynamic_Service (const ACE_Dynamic_Service&)) - ACE_UNIMPLEMENTED_FUNC (ACE_Dynamic_Service& operator= (const ACE_Dynamic_Service&)) -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Dynamic_Service.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -# include "ace/Dynamic_Service.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -# pragma implementation ("Dynamic_Service.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" - -#endif /* ACE_DYNAMIC_SERVICE_H */ diff --git a/deps/acelite/ace/Dynamic_Service.inl b/deps/acelite/ace/Dynamic_Service.inl deleted file mode 100644 index 5ae958d8f..000000000 --- a/deps/acelite/ace/Dynamic_Service.inl +++ /dev/null @@ -1,36 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_USES_WCHAR) - -template ACE_INLINE TYPE * -ACE_Dynamic_Service::instance (const ACE_ANTI_TCHAR *name) -{ - return instance (ACE_TEXT_CHAR_TO_TCHAR (name),false); -} - -template ACE_INLINE TYPE * -ACE_Dynamic_Service::instance (const ACE_ANTI_TCHAR *name, - bool no_global) -{ - return instance (ACE_TEXT_CHAR_TO_TCHAR (name),no_global); -} - -template ACE_INLINE TYPE * -ACE_Dynamic_Service::instance (const ACE_Service_Gestalt* repo, - const ACE_ANTI_TCHAR *name) -{ - return instance (repo, ACE_TEXT_CHAR_TO_TCHAR (name),false); -} - -template ACE_INLINE TYPE * -ACE_Dynamic_Service::instance (const ACE_Service_Gestalt* repo, - const ACE_ANTI_TCHAR *name, - bool no_global) -{ - return instance (repo, ACE_TEXT_CHAR_TO_TCHAR (name),no_global); -} - -#endif // ACE_USES_WCHAR - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Dynamic_Service_Base.cpp b/deps/acelite/ace/Dynamic_Service_Base.cpp deleted file mode 100644 index d38f1a5cd..000000000 --- a/deps/acelite/ace/Dynamic_Service_Base.cpp +++ /dev/null @@ -1,102 +0,0 @@ -#include "ace/Dynamic_Service_Base.h" -#include "ace/ACE.h" -#include "ace/Service_Config.h" -#include "ace/Service_Repository.h" -#include "ace/Service_Types.h" -#include "ace/Log_Category.h" - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - - -void -ACE_Dynamic_Service_Base::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Dynamic_Service_Base::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n"))); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -// Get the instance using for the current global -// service configuration repository. - -void * -ACE_Dynamic_Service_Base::instance (const ACE_TCHAR *name, bool no_global) -{ - ACE_TRACE ("ACE_Dynamic_Service_Base::instance"); - return instance (ACE_Service_Config::current (), name, no_global); -} - -// Find a service registration - -const ACE_Service_Type * -ACE_Dynamic_Service_Base::find_i (const ACE_Service_Gestalt* &repo, - const ACE_TCHAR *name, - bool no_global) -{ - ACE_TRACE ("ACE_Dynamic_Service_Base::find_i"); - const ACE_Service_Type *svc_rec = 0; - - ACE_Service_Gestalt* global = ACE_Service_Config::global (); - - for ( ; (repo->find (name, &svc_rec) == -1) && !no_global; repo = global) - { - // Check the static repo, too if different - if (repo == global) - break; - } - - return svc_rec; -} - - -// Get the instance using for specific configuration repository. -void * -ACE_Dynamic_Service_Base::instance (const ACE_Service_Gestalt* repo, - const ACE_TCHAR *name, - bool no_global) -{ - ACE_TRACE ("ACE_Dynamic_Service_Base::instance"); - - void *obj = 0; - const ACE_Service_Type_Impl *type = 0; - - const ACE_Service_Gestalt* repo_found = repo; - const ACE_Service_Type *svc_rec = find_i (repo_found, name, no_global); - if (svc_rec != 0) - { - type = svc_rec->type (); - if (type != 0) - obj = type->object (); - } - - if (ACE::debug ()) - { - ACE_GUARD_RETURN (ACE_Log_Msg, log_guard, *ACE_Log_Msg::instance (), 0); - - if (repo->repo_ != repo_found->repo_) - { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) DSB::instance, repo=%@, name=%s") - ACE_TEXT (" type=%@ => %@") - ACE_TEXT (" [in repo=%@]\n"), - repo->repo_, name, type, obj, - repo_found->repo_)); - } - else - { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) DSB::instance, repo=%@, name=%s") - ACE_TEXT (" type=%@ => %@\n"), - repo->repo_, name, type, obj)); - } - } - - return obj; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Dynamic_Service_Base.h b/deps/acelite/ace/Dynamic_Service_Base.h deleted file mode 100644 index 3d4649203..000000000 --- a/deps/acelite/ace/Dynamic_Service_Base.h +++ /dev/null @@ -1,71 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Dynamic_Service_Base.h - * - * @author Prashant Jain - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_DYNAMIC_SERVICE_BASE_H -#define ACE_DYNAMIC_SERVICE_BASE_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Service_Gestalt; -class ACE_Service_Type; - -/** - * @class ACE_Dynamic_Service_Base - * - * @brief Base class for all ACE_Dynamic_Service instantiations. - * - * Factors out common code shared by all ACE_Dynamic_Service - * instantiations, this avoid code bloat. - */ -class ACE_Export ACE_Dynamic_Service_Base -{ -public: - /// Dump the current static of the object - void dump (void) const; - -protected: - /// Perform the default repo search, but optionally skip searching the global - /// repo. - static void* instance (const ACE_TCHAR *name, bool no_global = false); - - static void* instance (const ACE_Service_Gestalt* repo, - const ACE_TCHAR *name, - bool no_global = false); - - /// No need to create, or assign instances of this class - ACE_Dynamic_Service_Base (void); - ~ACE_Dynamic_Service_Base (void); - const ACE_Dynamic_Service_Base& operator= (const ACE_Dynamic_Service_Base&); - -private: - /// Implement the service search policy, i.e. "look for the service first - /// locally and then globally" - static const ACE_Service_Type *find_i (const ACE_Service_Gestalt* &repo, - const ACE_TCHAR *name, - bool no_global); - - /// The dependency declaration class needs access to the service search - /// policy, implemented by find_i() - friend class ACE_Dynamic_Service_Dependency; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" -#endif /* ACE_DYNAMIC_SERVICE_BASE_H */ diff --git a/deps/acelite/ace/Dynamic_Service_Dependency.cpp b/deps/acelite/ace/Dynamic_Service_Dependency.cpp deleted file mode 100644 index 0a7e9e03d..000000000 --- a/deps/acelite/ace/Dynamic_Service_Dependency.cpp +++ /dev/null @@ -1,45 +0,0 @@ -#include "ace/ACE.h" -#include "ace/DLL_Manager.h" -#include "ace/Dynamic_Service_Dependency.h" -#include "ace/Service_Config.h" -#include "ace/Log_Category.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Dynamic_Service_Dependency::ACE_Dynamic_Service_Dependency (const ACE_TCHAR *principal) -{ - this->init (ACE_Service_Config::current (), principal); -} - -ACE_Dynamic_Service_Dependency::ACE_Dynamic_Service_Dependency (const ACE_Service_Gestalt *cfg, - const ACE_TCHAR *principal) -{ - this->init (cfg, principal); -} - - -ACE_Dynamic_Service_Dependency::~ACE_Dynamic_Service_Dependency (void) -{ - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%P|%t) DSD, this=%@ - destroying\n"), - this)); -} - -void -ACE_Dynamic_Service_Dependency::init (const ACE_Service_Gestalt *cfg, - const ACE_TCHAR *principal) -{ - const ACE_Service_Type* st = - ACE_Dynamic_Service_Base::find_i (cfg, principal,false); - if (ACE::debug ()) - { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%P|%t) DSD, this=%@ - creating dependency on "), this)); - st->dump (); - } - this->tracker_ = st->dll (); -} - - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Dynamic_Service_Dependency.h b/deps/acelite/ace/Dynamic_Service_Dependency.h deleted file mode 100644 index bb5294f40..000000000 --- a/deps/acelite/ace/Dynamic_Service_Dependency.h +++ /dev/null @@ -1,68 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Dynamic_Service_Dependency.h - * - * @author Iliyan Jeliazkov - */ -//============================================================================= - -#ifndef ACE_DYNAMIC_SERVICE_DEPENDENCY_H -#define ACE_DYNAMIC_SERVICE_DEPENDENCY_H - -#include /**/ "ace/pre.h" - - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Dynamic_Service_Base.h" -#include "ace/Service_Object.h" -#include "ace/DLL.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Dynamic_Service_Dependency - * - * @brief Provides a way to declare dependency on specific service, - * thus helping to avoid order of initialization issues with instances - * of an objects whose implementation code resides in dynamically loaded - * services. - * - * It is disastrous to have dynamically loadable services create and give away - * ownership of objects and then ending up being unloaded before all those - * instances have been deleted. Normally the code for such objects classes - * resides within the TEXT segment of the DLL, which implements the service. - * If a service gets removed, its DLL may be unmapped from memory and then - * any attempt to invoke a method on the said objects will cause SEGV. - * - * Such instances must contain a member of ACE_Dynamic_Service_Dependency - * initialized with the service they depend on. - * ACE_Dynamic_Service_Dependency's constructor and destructor are - * "magical" - they work by maintaining the underlying dynamic service's - * DLL reference count. - */ -class ACE_Export ACE_Dynamic_Service_Dependency -{ -public: - ACE_Dynamic_Service_Dependency (const ACE_Service_Gestalt *cfg, - const ACE_TCHAR *principal); - ACE_Dynamic_Service_Dependency (const ACE_TCHAR *principal); - ~ACE_Dynamic_Service_Dependency (void); - -private: - void init (const ACE_Service_Gestalt *cfg, const ACE_TCHAR *principal); - -private: - ACE_DLL tracker_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - - -#include /**/ "ace/post.h" - -#endif /* ACE_DYNAMIC_SERVICE_DEPENDENCY_H */ diff --git a/deps/acelite/ace/Encoding_Converter.cpp b/deps/acelite/ace/Encoding_Converter.cpp deleted file mode 100644 index 29a3a1d18..000000000 --- a/deps/acelite/ace/Encoding_Converter.cpp +++ /dev/null @@ -1,11 +0,0 @@ -#include "ace/Encoding_Converter.h" - -#if defined (ACE_USES_WCHAR) -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Encoding_Converter::~ACE_Encoding_Converter (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL -#endif /* ACE_USES_WCHAR */ diff --git a/deps/acelite/ace/Encoding_Converter.h b/deps/acelite/ace/Encoding_Converter.h deleted file mode 100644 index c430e8f93..000000000 --- a/deps/acelite/ace/Encoding_Converter.h +++ /dev/null @@ -1,68 +0,0 @@ -// -*- C++ -*- - -//========================================================================= -/** - * @file Encoding_Converter.h - * - * This class is the base class for all encoding converters that convert - * to and from UTF-8. - * - * @author Chad Elliott - */ -//========================================================================= - -#ifndef ACE_ENCODING_CONVERTER_H -#define ACE_ENCODING_CONVERTER_H - -#include /**/ "ace/pre.h" - -#include "ace/Basic_Types.h" - -#if defined (ACE_USES_WCHAR) -#include /**/ "ace/ACE_export.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** The base class for all ACE UTF Encoding Converters. - * This class provides a generic interface that is used to implement - * various UTF encoding conversion classes. - */ -class ACE_Export ACE_Encoding_Converter -{ -public: - /// This enum describes the various states that can be returned - /// from the to_utf8() and from_utf8() methods which depends on - /// both the source buffer and the size of the target buffer. - enum Result {CONVERSION_OK, - SOURCE_EXHAUSTED, - TARGET_EXHAUSTED, - SOURCE_ILLEGAL - }; - - /// This destructor is here (and virtual) because we have virtual - /// functions. - virtual ~ACE_Encoding_Converter (void); - - /// Convert the source (which can be in any encoding) to UTF-8 and - /// store it in the provided target buffer. - virtual Result to_utf8 (const void* source, - size_t source_size, - ACE_Byte* target, - size_t target_size, - bool strict = true) = 0; - - /// Convert the UTF-8 source into an alternate encoding and store it - /// in the provided target buffer. - virtual Result from_utf8 (const ACE_Byte* source, - size_t source_size, - void* target, - size_t target_size, - bool strict = true) = 0; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL -#endif /* ACE_USES_WCHAR */ - -#include /**/ "ace/post.h" - -#endif /* ACE_ENCODING_CONVERTER_H */ diff --git a/deps/acelite/ace/Encoding_Converter_Factory.cpp b/deps/acelite/ace/Encoding_Converter_Factory.cpp deleted file mode 100644 index 85f139fc1..000000000 --- a/deps/acelite/ace/Encoding_Converter_Factory.cpp +++ /dev/null @@ -1,73 +0,0 @@ -#include "ace/Encoding_Converter_Factory.h" - -#if defined (ACE_USES_WCHAR) -#include "ace/UTF32_Encoding_Converter.h" -#include "ace/UTF16_Encoding_Converter.h" -#include "ace/UTF8_Encoding_Converter.h" -#include "ace/OS_Memory.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Encoding_Converter* -ACE_Encoding_Converter_Factory::create ( - const ACE_Byte* source, - size_t source_size, - ACE_Encoding_Converter_Factory::Encoding_Hint hint) -{ -#if defined (ACE_BIG_ENDIAN) - bool const convert_for_bigendian = true; -#else - bool const convert_for_bigendian = false; -#endif /* ACE_BIG_ENDIAN */ - ACE_Encoding_Converter* converter = 0; - - switch (hint) - { - case ACE_UTF_32BE: - ACE_NEW_RETURN (converter, - ACE_UTF32_Encoding_Converter (!convert_for_bigendian), - 0); - break; - case ACE_UTF_32LE: - ACE_NEW_RETURN (converter, - ACE_UTF32_Encoding_Converter (convert_for_bigendian), - 0); - break; - case ACE_UTF_16BE: - ACE_NEW_RETURN (converter, - ACE_UTF16_Encoding_Converter (!convert_for_bigendian), - 0); - break; - case ACE_UTF_16LE: - ACE_NEW_RETURN (converter, - ACE_UTF16_Encoding_Converter (convert_for_bigendian), - 0); - break; - case ACE_UTF_8: - ACE_NEW_RETURN (converter, - ACE_UTF8_Encoding_Converter, - 0); - break; - default: - // First check for ASCII since much of ASCII text will appear to - // convert from UTF-16 to UTF-8. - converter = ACE_UTF8_Encoding_Converter::encoded (source, source_size); - if (converter != 0) - return converter; - - // Check for UTF-32 - converter = ACE_UTF32_Encoding_Converter::encoded (source, source_size); - if (converter != 0) - return converter; - - // Check for UTF-16 - converter = ACE_UTF16_Encoding_Converter::encoded (source, source_size); - if (converter != 0) - return converter; - } - - return converter; -} - -ACE_END_VERSIONED_NAMESPACE_DECL -#endif /* ACE_USES_WCHAR */ diff --git a/deps/acelite/ace/Encoding_Converter_Factory.h b/deps/acelite/ace/Encoding_Converter_Factory.h deleted file mode 100644 index 1a871a4cc..000000000 --- a/deps/acelite/ace/Encoding_Converter_Factory.h +++ /dev/null @@ -1,52 +0,0 @@ -// -*- C++ -*- - -//========================================================================= -/** - * @file Encoding_Converter_Factory.h - * - * This class can be used to create encoding converters of various types. - * - * @author Chad Elliott - */ -//========================================================================= - -#ifndef ACE_ENCODING_CONVERTER_FACTORY_H -#define ACE_ENCODING_CONVERTER_FACTORY_H - -#include /**/ "ace/pre.h" - -#include "ace/Basic_Types.h" - -#if defined (ACE_USES_WCHAR) -#include /**/ "ace/ACE_export.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Encoding_Converter; - -/** Create an encoding converter based on the source or hint. - * This class allows users to avoid knowing any concrete converter types. - */ -class ACE_Export ACE_Encoding_Converter_Factory -{ -public: - /// This enum is used to tell what type of converter to create. - enum Encoding_Hint { ACE_UTF_32BE, ACE_UTF_32LE, - ACE_UTF_16BE, ACE_UTF_16LE, - ACE_UTF_8, ACE_NONE - }; - - /// Create an encoding converter based on the source. If a hint is - /// given, it just creates the specified type of converter without looking - /// at the source. - static ACE_Encoding_Converter* create (const ACE_Byte* source, - size_t source_size, - Encoding_Hint hint = ACE_NONE); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL -#endif /* ACE_USES_WCHAR */ - -#include /**/ "ace/post.h" - -#endif /* ACE_ENCODING_CONVERTER_FACTORY_H */ diff --git a/deps/acelite/ace/Env_Value_T.cpp b/deps/acelite/ace/Env_Value_T.cpp deleted file mode 100644 index a63e76844..000000000 --- a/deps/acelite/ace/Env_Value_T.cpp +++ /dev/null @@ -1,10 +0,0 @@ -#ifndef ACE_ENV_VALUE_T_CPP -#define ACE_ENV_VALUE_T_CPP - -#include "ace/Env_Value_T.h" - -#if ! defined (__ACE_INLINE__) -#include "ace/Env_Value_T.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* ACE_ENV_VALUE_T_CPP */ diff --git a/deps/acelite/ace/Env_Value_T.h b/deps/acelite/ace/Env_Value_T.h deleted file mode 100644 index 4e268d3f9..000000000 --- a/deps/acelite/ace/Env_Value_T.h +++ /dev/null @@ -1,159 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Env_Value_T.h - * - * Template to encapsulate getting a value from an environment variable - * and using a supplied default value if not in the environment. - * - * @author Chris Cleeland (derived from work by Carlos O'Ryan) - */ -//============================================================================= - -#ifndef ACE_ENV_VALUE_T_H -#define ACE_ENV_VALUE_T_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" -#include "ace/Global_Macros.h" -#include "ace/OS_NS_stdlib.h" -#include "ace/Copy_Disabled.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Env_Value - * - * @brief Environment Variable Value - * - * Reads a variable from the user environment, providing a default - * value. - */ -template -class ACE_Env_Value : private ACE_Copy_Disabled -{ -public: - /** - * Default constructor which isn't bound to a specific environment - * variable name or a default value. Before being useful it must - * open()'d. - */ - ACE_Env_Value (void); - - /// Constructor that calls open(). - ACE_Env_Value (const ACE_TCHAR *varname, const T &vardefault); - - /// Destroy the value. - ~ACE_Env_Value (void); - - /// Returns the value as type T. - operator T (void); - - /// The constructor, read @a varname from the environment, using - /// @a defval as its value if it is not defined. - void open (const ACE_TCHAR *varname, const T &defval); - - /// Returns the name of the variable being tracked. - const ACE_TCHAR *varname (void) const; - -private: - void fetch_value (void); - - const ACE_TCHAR *varname_; - T value_; -}; - -/// Function to convert a string @a s into type @c T. -template void ACE_Convert (const ACE_TCHAR *s, T &t); - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Env_Value_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Env_Value_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template <> inline void -ACE_Convert (const ACE_TCHAR *s, ACE_TCHAR *&v) -{ - v = (ACE_TCHAR *) s; -} - -template <> inline void -ACE_Convert (const ACE_TCHAR *s, const ACE_TCHAR *&v) -{ - v = (const ACE_TCHAR *) s; -} - -template <> inline void -ACE_Convert (const ACE_TCHAR *s, short &si) -{ - si = static_cast (ACE_OS::strtol (s, 0, 10)); -} - -template <> inline void -ACE_Convert (const ACE_TCHAR *s, u_short &us) -{ - us = static_cast (ACE_OS::strtol (s, 0, 10)); -} - -template <> inline void -ACE_Convert (const ACE_TCHAR *s, u_int &i) -{ - i = static_cast (ACE_OS::strtol (s, 0, 10)); -} - -template <> inline void -ACE_Convert (const ACE_TCHAR *s, long &l) -{ - l = ACE_OS::strtol (s, 0, 10); -} - -template <> inline void -ACE_Convert (const ACE_TCHAR *s, int &i) -{ - i = static_cast (ACE_OS::strtol (s, 0, 10)); -} - -template <> inline void -ACE_Convert (const ACE_TCHAR *s, u_long &ul) -{ - ul = ACE_OS::strtoul (s, 0, 10); -} - -template <> inline void -ACE_Convert (const ACE_TCHAR *s, double &d) -{ - d = ACE_OS::strtod (s, 0); -} - -// Default calls a CTOR on type T of the form 'T::T(const char*)', but -// users can feel free to create their own specialized conversion -// functions if necessary, as shown above. Note that for 'char*' the -// default is used because a simple cast will be performed and no -// conversion will be necessary. -template inline void -ACE_Convert (const ACE_TCHAR *s, T &t) -{ - t = T (s); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Env_Value_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_ENV_VALUE_T_H */ diff --git a/deps/acelite/ace/Env_Value_T.inl b/deps/acelite/ace/Env_Value_T.inl deleted file mode 100644 index 1fc1b863f..000000000 --- a/deps/acelite/ace/Env_Value_T.inl +++ /dev/null @@ -1,58 +0,0 @@ -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE -ACE_Env_Value::operator T (void) -{ - return value_; -} - -template ACE_INLINE -ACE_Env_Value::ACE_Env_Value (void) - : varname_ (0) -{ -} - -template ACE_INLINE -ACE_Env_Value::ACE_Env_Value (const ACE_TCHAR *varname, - const T &defval) - : varname_ (varname), - value_(defval) -{ - this->fetch_value (); -} - -template ACE_INLINE void -ACE_Env_Value::open (const ACE_TCHAR *varname, - const T &defval) -{ - this->varname_ = varname; - this->value_ = defval; - this->fetch_value (); -} - -template ACE_INLINE void -ACE_Env_Value::fetch_value (void) -{ -#if defined (ACE_WIN32) - const ACE_TCHAR *env = ACE_OS::getenv (this->varname_); - if (env != 0) - ACE_Convert (env, value_); -#else - char *nenv = ACE_OS::getenv (ACE_TEXT_ALWAYS_CHAR (this->varname_)); - if (nenv != 0) - ACE_Convert (ACE_TEXT_CHAR_TO_TCHAR (nenv), this->value_); -#endif -} - -template ACE_INLINE const ACE_TCHAR* -ACE_Env_Value::varname (void) const -{ - return this->varname_; -} - -template ACE_INLINE -ACE_Env_Value::~ACE_Env_Value (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Event.cpp b/deps/acelite/ace/Event.cpp deleted file mode 100644 index 20fe07306..000000000 --- a/deps/acelite/ace/Event.cpp +++ /dev/null @@ -1,45 +0,0 @@ -#include "ace/Event.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Event.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Log_Category.h" -#include "ace/Condition_Attributes.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Event_T) - -template -ACE_Event_T::ACE_Event_T (int manual_reset, - int initial_state, - int type, - const ACE_TCHAR *name, - void *arg, - LPSECURITY_ATTRIBUTES sa) - : ACE_Event_Base () -{ - ACE_Condition_Attributes_T cond_attr (type); - if (ACE_OS::event_init (&this->handle_, - type, - &const_cast (cond_attr.attributes ()), - manual_reset, - initial_state, - name, - arg, - sa) != 0) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Event_T::ACE_Event_T"))); -} - -template -ACE_Event_T::~ACE_Event_T (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Event.h b/deps/acelite/ace/Event.h deleted file mode 100644 index a30420631..000000000 --- a/deps/acelite/ace/Event.h +++ /dev/null @@ -1,94 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Event.h - * - * Moved from Synch.h. - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_EVENT_H -#define ACE_EVENT_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Event_Base.h" -#include "ace/Time_Policy.h" -#include "ace/Time_Value_T.h" -#include "ace/Log_Category.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Event_T - * - * @brief A wrapper around the Win32 event locking mechanism. - * - * Portable implementation of an Event mechanism, which is native to - * Win32, but must be emulated on UNIX. All platforms support - * process-scope locking support. However, only Win32 platforms - * support global naming and system-scope locking support. - */ -template -class ACE_Event_T : public ACE_Event_Base -{ -public: - /// Constructor that creates event. - ACE_Event_T (int manual_reset = 0, - int initial_state = 0, - int type = USYNC_THREAD, - const ACE_TCHAR *name = 0, - void *arg = 0, - LPSECURITY_ATTRIBUTES sa = 0); - - /// Implicitly destroy the event variable. - virtual ~ACE_Event_T (void); - - /// Get the current time of day according to the queue's TIME_POLICY. - /// Allows users to initialize timeout values using correct time policy. - ACE_Time_Value_T gettimeofday (void) const; - - /// Allows applications to control how the event gets the time - /// of day. - void set_time_policy (TIME_POLICY const & time_policy); - - /// Declare the dynamic allocation hooks - ACE_ALLOC_HOOK_DECLARE; - -protected: - - /// The policy to return the current time of day - TIME_POLICY time_policy_; - -private: - // = Prevent copying. - ACE_Event_T (const ACE_Event_T& event); - const ACE_Event_T &operator= (const ACE_Event_T &rhs); -}; - -typedef ACE_Event_T ACE_Event; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Event.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Event.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Event.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_EVENT_H */ diff --git a/deps/acelite/ace/Event.inl b/deps/acelite/ace/Event.inl deleted file mode 100644 index b8a688be7..000000000 --- a/deps/acelite/ace/Event.inl +++ /dev/null @@ -1,18 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Time_Value_T -ACE_Event_T::gettimeofday (void) const -{ - return this->time_policy_ (); -} - -template -void -ACE_Event_T::set_time_policy (TIME_POLICY const & rhs) -{ - this->time_policy_ = rhs; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Event_Base.cpp b/deps/acelite/ace/Event_Base.cpp deleted file mode 100644 index 3ec4ea02b..000000000 --- a/deps/acelite/ace/Event_Base.cpp +++ /dev/null @@ -1,79 +0,0 @@ -#include "ace/Event_Base.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Event_Base.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Log_Category.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Event_Base) - -ACE_Event_Base::ACE_Event_Base () - : removed_ (false) -{ -} - -ACE_Event_Base::~ACE_Event_Base (void) -{ - this->remove (); -} - -int -ACE_Event_Base::remove (void) -{ - int result = 0; - if (!this->removed_) - { - this->removed_ = true; - result = ACE_OS::event_destroy (&this->handle_); - } - return result; -} - -int -ACE_Event_Base::wait (void) -{ - return ACE_OS::event_wait (&this->handle_); -} - -int -ACE_Event_Base::wait (const ACE_Time_Value *abstime, int use_absolute_time) -{ - return ACE_OS::event_timedwait (&this->handle_, - const_cast (abstime), - use_absolute_time); -} - -int -ACE_Event_Base::signal (void) -{ - return ACE_OS::event_signal (&this->handle_); -} - -int -ACE_Event_Base::pulse (void) -{ - return ACE_OS::event_pulse (&this->handle_); -} - -int -ACE_Event_Base::reset (void) -{ - return ACE_OS::event_reset (&this->handle_); -} - -void -ACE_Event_Base::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Event_Base.h b/deps/acelite/ace/Event_Base.h deleted file mode 100644 index a158c5e67..000000000 --- a/deps/acelite/ace/Event_Base.h +++ /dev/null @@ -1,139 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Event_Base.h - * - * Moved from Synch.h. - * - * @author Martin Corino - */ -//========================================================================== - -#ifndef ACE_EVENT_BASE_H -#define ACE_EVENT_BASE_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/OS_NS_Thread.h" -#include "ace/Time_Value.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Event_Base - * - * @brief A base class for wrappers around the Win32 event locking - * mechanism. - * - * Portable implementation of an Event mechanism, which is native to - * Win32, but must be emulated on UNIX. All platforms support - * process-scope locking support. However, only Win32 platforms - * support global naming and system-scope locking support. - */ -class ACE_Export ACE_Event_Base -{ -public: - /// Implicitly destroy the event variable. - virtual ~ACE_Event_Base (void); - - /** - * Explicitly destroy the event variable. Note that only one thread - * should call this method since it doesn't protect against race - * conditions. - */ - int remove (void); - - /// Underlying handle to event. - ACE_event_t handle (void) const; - - /** - * Set the underlying handle to event. Note that this method assumes - * ownership of the and will close it down in . If - * you want the to stay open when is called make - * sure to call on the before closing it. You are - * responsible for the closing the existing before - * overwriting it. - */ - void handle (ACE_event_t new_handle); - - /** - * if MANUAL reset - * sleep till the event becomes signaled - * event remains signaled after wait() completes. - * else AUTO reset - * sleep till the event becomes signaled - * event resets wait() completes. - */ - int wait (void); - - /// Same as wait() above, but this one can be timed - /// @a abstime is absolute time-of-day if if @a use_absolute_time - /// is non-0, else it is relative time. - int wait (const ACE_Time_Value *abstime, - int use_absolute_time = 1); - - /** - * if MANUAL reset - * wake up all waiting threads - * set to signaled state - * else AUTO reset - * if no thread is waiting, set to signaled state - * if thread(s) are waiting, wake up one waiting thread and - * reset event - */ - int signal (void); - - /** - * if MANUAL reset - * wakeup all waiting threads and - * reset event - * else AUTO reset - * wakeup one waiting thread (if present) and - * reset event - */ - int pulse (void); - - /// Set to nonsignaled state. - int reset (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Only derived classes allowed to construct event. - ACE_Event_Base (); - - - /// The underlying handle. - ACE_event_t handle_; - - /// Keeps track of whether has been called yet to avoid - /// multiple calls, e.g., explicitly and implicitly in the - /// destructor. This flag isn't protected by a lock, so make sure - /// that you don't have multiple threads simultaneously calling - /// on the same object, which is a bad idea anyway... - bool removed_; - -private: - // = Prevent copying. - ACE_Event_Base (const ACE_Event_Base& event); - const ACE_Event_Base &operator= (const ACE_Event_Base &rhs); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Event_Base.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_EVENT_BASE_H */ diff --git a/deps/acelite/ace/Event_Base.inl b/deps/acelite/ace/Event_Base.inl deleted file mode 100644 index fa8cf909e..000000000 --- a/deps/acelite/ace/Event_Base.inl +++ /dev/null @@ -1,16 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE ACE_event_t -ACE_Event_Base::handle (void) const -{ - return this->handle_; -} - -ACE_INLINE void -ACE_Event_Base::handle (ACE_event_t new_handle) -{ - this->handle_ = new_handle; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Event_Handler.cpp b/deps/acelite/ace/Event_Handler.cpp deleted file mode 100644 index 6a44bf58e..000000000 --- a/deps/acelite/ace/Event_Handler.cpp +++ /dev/null @@ -1,397 +0,0 @@ -// Event_Handler.cpp -#include "ace/Event_Handler.h" -#include "ace/OS_Errno.h" -#include "ace/Reactor.h" -#include "ace/Thread_Manager.h" -/* Need to see if ACE_HAS_BUILTIN_ATOMIC_OP defined */ -#include "ace/Atomic_Op.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Event_Handler.inl" -#endif /* __ACE_INLINE__ */ - -#include - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Implement conceptually abstract virtual functions in the base class -// so derived classes don't have to implement unused ones. -ACE_Event_Handler::ACE_Event_Handler (ACE_Reactor *r, - int p) - : reference_count_ (1), - priority_ (p), - reactor_ (r), - reference_counting_policy_ (Reference_Counting_Policy::DISABLED) -{ - // ACE_TRACE ("ACE_Event_Handler::ACE_Event_Handler"); -} - -ACE_Event_Handler::~ACE_Event_Handler (void) -{ - // ACE_TRACE ("ACE_Event_Handler::~ACE_Event_Handler"); -} - -// Gets the file descriptor associated with this I/O device. -ACE_HANDLE -ACE_Event_Handler::get_handle (void) const -{ - ACE_TRACE ("ACE_Event_Handler::get_handle"); - return ACE_INVALID_HANDLE; -} - -// Sets the file descriptor associated with this I/O device. -void -ACE_Event_Handler::set_handle (ACE_HANDLE) -{ - ACE_TRACE ("ACE_Event_Handler::set_handle"); -} - -// Gets the priority of this handler. -int -ACE_Event_Handler::priority (void) const -{ - ACE_TRACE ("ACE_Event_Handler::priority"); - return this->priority_; -} - -// Sets the priority -void -ACE_Event_Handler::priority (int priority) -{ - ACE_TRACE ("ACE_Event_Handler::priority"); - this->priority_ = priority; -} - -// Called when the object is about to be removed from the Dispatcher -// tables. -int -ACE_Event_Handler::handle_close (ACE_HANDLE, ACE_Reactor_Mask) -{ - ACE_TRACE ("ACE_Event_Handler::handle_close"); - return -1; -} - -// Called when input becomes available on fd. -int -ACE_Event_Handler::handle_input (ACE_HANDLE) -{ - ACE_TRACE ("ACE_Event_Handler::handle_input"); - return -1; -} - -// Called when output is possible on fd. -int -ACE_Event_Handler::handle_output (ACE_HANDLE) -{ - ACE_TRACE ("ACE_Event_Handler::handle_output"); - return -1; -} - -// Called when urgent data is available on fd. -int -ACE_Event_Handler::handle_exception (ACE_HANDLE) -{ - ACE_TRACE ("ACE_Event_Handler::handle_exception"); - return -1; -} - -// Called when timer expires, TV stores the current time. -int -ACE_Event_Handler::handle_timeout (const ACE_Time_Value &, const void *) -{ - ACE_TRACE ("ACE_Event_Handler::handle_timeout"); - return -1; -} - -// Called when a monitored Process exits -int -ACE_Event_Handler::handle_exit (ACE_Process *) -{ - ACE_TRACE ("ACE_Event_Handler::handle_exit"); - return -1; -} - -// Called when a registered signal occurs. -int -ACE_Event_Handler::handle_signal (int, siginfo_t *, ucontext_t *) -{ - ACE_TRACE ("ACE_Event_Handler::handle_signal"); - return -1; -} - -int -ACE_Event_Handler::resume_handler (void) -{ - ACE_TRACE ("ACE_Event_Handler::resume_handler"); - - // Return a default value and allow the reactor to take care of - // resuming the handler - return ACE_Event_Handler::ACE_REACTOR_RESUMES_HANDLER; -} - -int -ACE_Event_Handler::handle_qos (ACE_HANDLE) -{ - ACE_TRACE ("ACE_Event_Handler::handle_qos"); - return -1; -} - -int -ACE_Event_Handler::handle_group_qos (ACE_HANDLE) -{ - ACE_TRACE ("ACE_Event_Handler::handle_group_qos"); - return -1; -} - -void -ACE_Event_Handler::reactor (ACE_Reactor *reactor) -{ - ACE_TRACE ("ACE_Event_Handler::reactor"); - this->reactor_ = reactor; -} - -ACE_Reactor * -ACE_Event_Handler::reactor (void) const -{ - ACE_TRACE ("ACE_Event_Handler::reactor"); - return this->reactor_; -} - -ACE_Reactor_Timer_Interface * -ACE_Event_Handler::reactor_timer_interface (void) const -{ - ACE_TRACE ("ACE_Event_Handler::reactor_timer_interface"); - return this->reactor_; -} - -ACE_Event_Handler::Reference_Count -ACE_Event_Handler::add_reference (void) -{ - bool const reference_counting_required = - this->reference_counting_policy ().value () == - ACE_Event_Handler::Reference_Counting_Policy::ENABLED; - - if (reference_counting_required) - return ++this->reference_count_; - else - return 1; -} - -ACE_Event_Handler::Reference_Count -ACE_Event_Handler::remove_reference (void) -{ - bool const reference_counting_required = - this->reference_counting_policy ().value () == - ACE_Event_Handler::Reference_Counting_Policy::ENABLED; - - if (reference_counting_required) - { - Reference_Count result = - --this->reference_count_; - - if (result == 0) - delete this; - - return result; - } - else - { - return 1; - } -} - -ACE_Event_Handler::Policy::~Policy (void) -{ -} - -ACE_Event_Handler::Reference_Counting_Policy::Reference_Counting_Policy (Reference_Counting_Policy::Value value) - : value_ (value) -{ -} - -ACE_Event_Handler::Reference_Counting_Policy::Value -ACE_Event_Handler::Reference_Counting_Policy::value (void) const -{ - return this->value_; -} - -void -ACE_Event_Handler::Reference_Counting_Policy::value (ACE_Event_Handler::Reference_Counting_Policy::Value value) -{ - this->value_ = value; -} - -ACE_Event_Handler::Reference_Counting_Policy & -ACE_Event_Handler::reference_counting_policy (void) -{ - return this->reference_counting_policy_; -} - -ACE_THR_FUNC_RETURN -ACE_Event_Handler::read_adapter (void *args) -{ - ACE_Event_Handler *this_ptr = static_cast (args); - ACE_Reactor *r = this_ptr->reactor (); - - while (this_ptr->handle_input (ACE_STDIN) != -1) - continue; - - this_ptr->handle_close (ACE_STDIN, ACE_Event_Handler::READ_MASK); - // It's possible for handle_close() to "delete this" so we need to - // cache the reactor pointer and use it here. - r->notify (); - - return 0; -} - -int -ACE_Event_Handler::register_stdin_handler (ACE_Event_Handler *eh, - ACE_Reactor *reactor, - ACE_Thread_Manager *thr_mgr, - int flags) -{ -#if defined (ACE_WIN32) - ACE_UNUSED_ARG (reactor); - - eh->reactor (reactor); - return thr_mgr->spawn (&read_adapter, static_cast (eh), flags); -#else - // Keep compilers happy. - ACE_UNUSED_ARG (flags); - ACE_UNUSED_ARG (thr_mgr); - return reactor->register_handler (ACE_STDIN, - eh, - ACE_Event_Handler::READ_MASK); -#endif /* ACE_WIN32 */ -} - -int -ACE_Event_Handler::remove_stdin_handler (ACE_Reactor *reactor, - ACE_Thread_Manager * /* thr_mgr */) -{ -#if defined (ACE_WIN32) - ACE_UNUSED_ARG (reactor); - - // What should we do here? - ACE_NOTSUP_RETURN (-1); -#else - return reactor->remove_handler (ACE_STDIN, - ACE_Event_Handler::READ_MASK); -#endif /* ACE_WIN32 */ -} - -// --------------------------------------------------------------------- - -ACE_Event_Handler_var::ACE_Event_Handler_var (void) - : ptr_ (0) -{ -} - -ACE_Event_Handler_var::ACE_Event_Handler_var (ACE_Event_Handler *p) - : ptr_ (p) -{ -} - -ACE_Event_Handler_var::ACE_Event_Handler_var (const ACE_Event_Handler_var &b) - : ptr_ (b.ptr_) -{ - if (this->ptr_ != 0) - { - this->ptr_->add_reference (); - } -} - -ACE_Event_Handler_var::~ACE_Event_Handler_var (void) -{ - if (this->ptr_ != 0) - { - ACE_Errno_Guard eguard (errno); - this->ptr_->remove_reference (); - } -} - -ACE_Event_Handler_var & -ACE_Event_Handler_var::operator= (ACE_Event_Handler *p) -{ - if (this->ptr_ != p) - { - ACE_Event_Handler_var tmp (p); - std::swap (this->ptr_, tmp.ptr_); - } - - return *this; -} - -ACE_Event_Handler_var & -ACE_Event_Handler_var::operator= (const ACE_Event_Handler_var &b) -{ - ACE_Event_Handler_var tmp (b); - std::swap (this->ptr_, tmp.ptr_); - - return *this; -} - -ACE_Event_Handler * -ACE_Event_Handler_var::operator->() const -{ - return this->ptr_; -} - -ACE_Event_Handler * -ACE_Event_Handler_var::handler (void) const -{ - return this->ptr_; -} - -ACE_Event_Handler * -ACE_Event_Handler_var::release (void) -{ - ACE_Event_Handler * const old = this->ptr_; - this->ptr_ = 0; - return old; -} - -void -ACE_Event_Handler_var::reset (ACE_Event_Handler *p) -{ - *this = p; -} - -#if defined (ACE_HAS_CPP11) -ACE_Event_Handler_var::operator bool() const -{ - return this->ptr_ == nullptr ? false : true; -} - -bool -ACE_Event_Handler_var::operator ==(std::nullptr_t) const -{ - return this->ptr_ == nullptr ? true : false; -} - -bool -ACE_Event_Handler_var::operator !=(std::nullptr_t) const -{ - return this->ptr_ == nullptr ? false : true; - -} -#endif /* ACE_HAS_CPP11 */ - -// --------------------------------------------------------------------- - -ACE_Notification_Buffer::ACE_Notification_Buffer (void) - : eh_ (0), - mask_ (ACE_Event_Handler::NULL_MASK) -{ - ACE_TRACE ("ACE_Notification_Buffer::ACE_Notification_Buffer"); -} - -ACE_Notification_Buffer::ACE_Notification_Buffer (ACE_Event_Handler *eh, - ACE_Reactor_Mask mask) - : eh_ (eh), - mask_ (mask) -{ - ACE_TRACE ("ACE_Notification_Buffer::ACE_Notification_Buffer"); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Event_Handler.h b/deps/acelite/ace/Event_Handler.h deleted file mode 100644 index caf5068a0..000000000 --- a/deps/acelite/ace/Event_Handler.h +++ /dev/null @@ -1,426 +0,0 @@ -/* -*- C++ -*- */ - -//========================================================================== -/** - * @file Event_Handler.h - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_EVENT_HANDLER_H -#define ACE_EVENT_HANDLER_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/os_include/os_signal.h" -#include "ace/Atomic_Op.h" -#include "ace/OS_NS_Thread.h" -#include "ace/Synch_Traits.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward declaration. -class ACE_Message_Block; -class ACE_Reactor; -class ACE_Reactor_Timer_Interface; -class ACE_Thread_Manager; -class ACE_Process; - -typedef unsigned long ACE_Reactor_Mask; - -/** - * @class ACE_Event_Handler - * - * @brief - * Provides an abstract interface for handling various types of - * I/O, timer, and signal events. - * - * Subclasses read/write input/output on an I/O descriptor, - * handle an exception raised on an I/O descriptor, handle a - * timer's expiration, or handle a signal. - */ -class ACE_Export ACE_Event_Handler -{ -public: - enum - { - LO_PRIORITY = 0, - HI_PRIORITY = 10, - NULL_MASK = 0, -#if defined (ACE_USE_POLL) - READ_MASK = POLLIN, - WRITE_MASK = POLLOUT, - EXCEPT_MASK = POLLPRI, -#else /* USE SELECT */ - READ_MASK = (1 << 0), - WRITE_MASK = (1 << 1), - EXCEPT_MASK = (1 << 2), -#endif /* ACE_USE_POLL */ - ACCEPT_MASK = (1 << 3), - CONNECT_MASK = (1 << 4), - TIMER_MASK = (1 << 5), - QOS_MASK = (1 << 6), - GROUP_QOS_MASK = (1 << 7), - SIGNAL_MASK = (1 << 8), - ALL_EVENTS_MASK = READ_MASK | - WRITE_MASK | - EXCEPT_MASK | - ACCEPT_MASK | - CONNECT_MASK | - TIMER_MASK | - QOS_MASK | - GROUP_QOS_MASK | - SIGNAL_MASK, - RWE_MASK = READ_MASK | - WRITE_MASK | - EXCEPT_MASK, - DONT_CALL = (1 << 9) - }; - - /// Destructor is virtual to enable proper cleanup. - virtual ~ACE_Event_Handler (void); - - /// Get the I/O handle. - virtual ACE_HANDLE get_handle (void) const; - - /// Set the I/O handle. - virtual void set_handle (ACE_HANDLE); - - // = Get/set priority - - /// Get the priority of the Event_Handler. - /// @note Priorities run from MIN_PRIORITY (which is the "lowest priority") - /// to MAX_PRIORITY (which is the "highest priority"). - virtual int priority (void) const; - - /// Set the priority of the Event_Handler. - virtual void priority (int priority); - - /// Called when input events occur (e.g., connection or data). - virtual int handle_input (ACE_HANDLE fd = ACE_INVALID_HANDLE); - - /// Called when output events are possible (e.g., when flow control - /// abates or non-blocking connection completes). - virtual int handle_output (ACE_HANDLE fd = ACE_INVALID_HANDLE); - - /// Called when an exceptional events occur (e.g., SIGURG). - virtual int handle_exception (ACE_HANDLE fd = ACE_INVALID_HANDLE); - - /** - * Called when timer expires. @a current_time represents the current - * time that the Event_Handler was selected for timeout - * dispatching and @a act is the asynchronous completion token that - * was passed in when was invoked. - */ - virtual int handle_timeout (const ACE_Time_Value ¤t_time, - const void *act = 0); - - /// Called when a process exits. - virtual int handle_exit (ACE_Process *); - - /// Called when a handle_*() method returns -1 or when the - /// remove_handler() method is called on an ACE_Reactor. The - /// @a close_mask indicates which event has triggered the - /// handle_close() method callback on a particular @a handle. - virtual int handle_close (ACE_HANDLE handle, - ACE_Reactor_Mask close_mask); - - /// Called when object is signaled by OS (either via UNIX signals or - /// when a Win32 object becomes signaled). - virtual int handle_signal (int signum, siginfo_t * = 0, ucontext_t * = 0); - - enum - { - /// The handler is not resumed at all. Could lead to deadlock.. - ACE_EVENT_HANDLER_NOT_RESUMED = -1, - /// The reactor takes responsibility of resuming the handler and - /// is the default - ACE_REACTOR_RESUMES_HANDLER = 0, - /// The application takes responsibility of resuming the handler - ACE_APPLICATION_RESUMES_HANDLER - }; - - /** - * Called to figure out whether the handler needs to resumed by the - * reactor or the application can take care of it. The default - * value of 0 would be returned which would allow the reactor to - * take care of resumption of the handler. The application can - * return a value more than zero and decide to resume the handler - * themselves. - * - * @note This method has an affect only when used with the - * ACE_Dev_Poll_Reactor (and then, only on Linux) or the ACE_TP_Reactor. - */ - virtual int resume_handler (void); - - virtual int handle_qos (ACE_HANDLE = ACE_INVALID_HANDLE); - virtual int handle_group_qos (ACE_HANDLE = ACE_INVALID_HANDLE); - - // = Accessors to set/get the various event demultiplexors. - /// Set the event demultiplexors. - virtual void reactor (ACE_Reactor *reactor); - - /// Get the event demultiplexors. - virtual ACE_Reactor *reactor (void) const; - - /// Get only the reactor's timer related interface. - virtual ACE_Reactor_Timer_Interface *reactor_timer_interface (void) const; - - /** - * Used to read from non-socket ACE_HANDLEs in our own thread to - * work around Win32 limitations that don't allow us to 'able on - * Win32. - */ - static int register_stdin_handler (ACE_Event_Handler *eh, - ACE_Reactor *reactor, - ACE_Thread_Manager *thr_mgr, - int flags = THR_DETACHED); - - /// Performs the inverse of the register_stdin_handler() method. - static int remove_stdin_handler (ACE_Reactor *reactor, - ACE_Thread_Manager *thr_mgr); - - /// Reference count type. - typedef long Reference_Count; - - /// Increment reference count on the handler. - /** - * This method is called when the handler is registered with the - * Reactor and when the Reactor makes an upcall on the handler. - * Reference count is 1 when the handler is created. - * - * @return Current reference count. - */ - virtual Reference_Count add_reference (void); - - /// Decrement reference count on the handler. - /** - * This method is called when the handler is removed from the - * Reactor and when an upcall made on the handler by the Reactor - * completes. Handler is deleted when the reference count reaches - * 0. - * - * @return Current reference count. - */ - virtual Reference_Count remove_reference (void); - - /** - * @class Policy - * - * @brief Base class for all handler policies. - */ - class ACE_Export Policy - { - - public: - - /// Virtual destructor. - virtual ~Policy (void); - }; - - /** - * @class Reference_Counting_Policy - * - * @brief - * This policy dictates the reference counting requirements - * for the handler. - * - * This policy allows applications to configure whether it wants the - * Reactor to call add_reference() and remove_reference() during - * registrations, removals, and upcalls. - * - * Default: DISABLED. - */ - class ACE_Export Reference_Counting_Policy : public Policy - { - /// This policy can only be created by the handler. - friend class ACE_Event_Handler; - - public: - - enum Value - { - /// Perform reference counting. - ENABLED, - /// Don't perform reference counting. - DISABLED - }; - - /// Current Reference_Counting_Policy. - Value value (void) const; - - /// Update Reference_Counting_Policy. - void value (Value value); - - private: - - /// Private constructor. - Reference_Counting_Policy (Value value); - - /// The value of the policy. - Value value_; - }; - - /// Current Reference_Counting_Policy. - Reference_Counting_Policy &reference_counting_policy (void); - -protected: - /// Force ACE_Event_Handler to be an abstract base class. - ACE_Event_Handler (ACE_Reactor * = 0, - int priority = ACE_Event_Handler::LO_PRIORITY); - - /// Typedef for implementation of reference counting. - typedef ACE_Atomic_Op Atomic_Reference_Count; - - /// Reference count. - Atomic_Reference_Count reference_count_; - -private: - - /// Priority of this Event_Handler. - int priority_; - - /// Pointer to the various event demultiplexors. - ACE_Reactor *reactor_; - - /// Reference counting requirements. - Reference_Counting_Policy reference_counting_policy_; -}; - -/** - * @class ACE_Event_Handler_var - * - * @brief Auto pointer like class for Event Handlers. - * - * Used to manage lifecycle of handlers. This class calls - * ACE_Event_Handler::remove_reference() in its destructor. - */ -class ACE_Export ACE_Event_Handler_var -{ -public: - /// Default constructor. - ACE_Event_Handler_var (void); - - /// Construct with a handler. - ACE_Event_Handler_var (ACE_Event_Handler *p); - - /// Copy constructor. - ACE_Event_Handler_var (const ACE_Event_Handler_var &b); - - /// Destructor. - ~ACE_Event_Handler_var (void); - - /// Assignment to a handler. - ACE_Event_Handler_var &operator= (ACE_Event_Handler *p); - - /// Assignment to a ACE_Event_Handler_var. - ACE_Event_Handler_var &operator= (const ACE_Event_Handler_var &b); - - /// Overloaded "->". - ACE_Event_Handler *operator-> () const; - - /// Access the handler. - ACE_Event_Handler *handler (void) const; - - /// Release the handler. - ACE_Event_Handler *release (void); - - /// Reset the handler. - void reset (ACE_Event_Handler *p = 0); - -#if defined (ACE_HAS_CPP11) - /// Bool operator to check if the ACE_Event_Handler_var has a value - explicit operator bool() const; - /// Equality operator to compare with nullptr_t - bool operator ==(std::nullptr_t) const; - /// Not equal operator to compare with nullptr_t - bool operator !=(std::nullptr_t) const; -#endif - -private: - - /// Handler. - ACE_Event_Handler *ptr_; -}; - -#if defined ACE_HAS_CPP11 - -/// Define that we can use in user code to check if this -/// helper factory method is there -#define ACE_HAS_ACE_MAKE_EVENT_HANDLER - -namespace ACE -{ - /// With C++11 it is common to not use C++ new and delete, but - /// use std::make_shared and std::make_unique. This will not - /// work for ACE event handlers so we introduce a new - /// ACE::make_event_handler which can be used in user code to - /// allocate a new ACE event handler instance and directly assign - /// it to a ACE_Event_Handler_var - /// As user this now makes it for example possible to implement - /// the following when Simple_Handler is derived from ACE_Event_Handler - /// ACE_Event_Handler_var v = - /// ACE::make_event_handler (reactor.get()); - template::value>::type, - typename ...Args> inline - ACE_Event_Handler_var make_event_handler (Args&& ...args) - { - return ACE_Event_Handler_var (new T (std::forward (args)...)); - } -} - -#endif - -/** - * @class ACE_Notification_Buffer - * - * @brief Simple wrapper for passing ACE_Event_Handler *s and - * ACE_Reactor_Masks between threads. - */ -class ACE_Export ACE_Notification_Buffer -{ -public: - ACE_Notification_Buffer (void); - - ACE_Notification_Buffer (ACE_Event_Handler *eh, - ACE_Reactor_Mask mask); - - /// Default destructor. - ~ACE_Notification_Buffer (void); - - /// Pointer to the Event_Handler that will be dispatched - /// by the main event loop. - ACE_Event_Handler *eh_; - - /// Mask that indicates which method to call. - ACE_Reactor_Mask mask_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Event_Handler.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_EVENT_HANDLER_H */ diff --git a/deps/acelite/ace/Event_Handler.inl b/deps/acelite/ace/Event_Handler.inl deleted file mode 100644 index 4ad5d2d26..000000000 --- a/deps/acelite/ace/Event_Handler.inl +++ /dev/null @@ -1,9 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Notification_Buffer::~ACE_Notification_Buffer (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Event_Handler_Handle_Timeout_Upcall.cpp b/deps/acelite/ace/Event_Handler_Handle_Timeout_Upcall.cpp deleted file mode 100644 index f361e5aae..000000000 --- a/deps/acelite/ace/Event_Handler_Handle_Timeout_Upcall.cpp +++ /dev/null @@ -1,99 +0,0 @@ -#include "ace/Event_Handler_Handle_Timeout_Upcall.h" -#include "ace/Reactor_Timer_Interface.h" -#include "ace/Abstract_Timer_Queue.h" - -#if !defined(__ACE_INLINE__) -# include "ace/Event_Handler_Handle_Timeout_Upcall.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Event_Handler_Handle_Timeout_Upcall) - -ACE_Event_Handler_Handle_Timeout_Upcall:: -ACE_Event_Handler_Handle_Timeout_Upcall (void) : - requires_reference_counting_ (0) -{ -} - -ACE_Event_Handler_Handle_Timeout_Upcall:: -~ACE_Event_Handler_Handle_Timeout_Upcall (void) -{ -} - -int -ACE_Event_Handler_Handle_Timeout_Upcall:: -timeout (ACE_Timer_Queue &timer_queue, - ACE_Event_Handler *event_handler, - const void *act, - int recurring_timer, - const ACE_Time_Value &cur_time) -{ - int requires_reference_counting = 0; - - if (!recurring_timer) - { - requires_reference_counting = - event_handler->reference_counting_policy ().value () == - ACE_Event_Handler::Reference_Counting_Policy::ENABLED; - } - - // Upcall to the s handle_timeout method. - if (event_handler->handle_timeout (cur_time, act) == -1) - { - if (event_handler->reactor_timer_interface ()) - event_handler->reactor_timer_interface ()->cancel_timer (event_handler, 0); - else - timer_queue.cancel (event_handler, 0); // 0 means "call handle_close()". - } - - if (!recurring_timer && - requires_reference_counting) - { - event_handler->remove_reference (); - } - - return 0; -} - -int -ACE_Event_Handler_Handle_Timeout_Upcall:: -cancel_type (ACE_Timer_Queue &, - ACE_Event_Handler *event_handler, - int dont_call, - int &requires_reference_counting) -{ - requires_reference_counting = - event_handler->reference_counting_policy ().value () == - ACE_Event_Handler::Reference_Counting_Policy::ENABLED; - - // Upcall to the s handle_close method - if (dont_call == 0) - event_handler->handle_close (ACE_INVALID_HANDLE, - ACE_Event_Handler::TIMER_MASK); - - return 0; -} - -int -ACE_Event_Handler_Handle_Timeout_Upcall:: -deletion (ACE_Timer_Queue &timer_queue, - ACE_Event_Handler *event_handler, - const void *) -{ - int requires_reference_counting = 0; - - this->cancel_type (timer_queue, - event_handler, - 0, - requires_reference_counting); - - this->cancel_timer (timer_queue, - event_handler, - 0, - requires_reference_counting); - - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Event_Handler_Handle_Timeout_Upcall.h b/deps/acelite/ace/Event_Handler_Handle_Timeout_Upcall.h deleted file mode 100644 index da0d57c7e..000000000 --- a/deps/acelite/ace/Event_Handler_Handle_Timeout_Upcall.h +++ /dev/null @@ -1,103 +0,0 @@ -#ifndef ACE_EVENT_HANDLER_HANDLE_TIMEOUT_UPCALL_H -#define ACE_EVENT_HANDLER_HANDLE_TIMEOUT_UPCALL_H - -#include /**/ "ace/pre.h" - -/** - * @file Event_Handler_Handle_Timeout_Upcall.h - * - * @author Carlos O'Ryan - * - * Based on classes and files developed by Doug Schmidt, Darrell - * Brunsch, Irfan Pyarali and a cast of thousands. - */ - -#include "ace/Timer_Queuefwd.h" -#include "ace/Copy_Disabled.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Time_Value; - -/** - * @class ACE_Event_Handler_Handle_Timeout_Upcall - * - * @brief Functor for Timer_Queues. - * - * This class implements the functor required by the Timer - * Queue to call on ACE_Event_Handlers. - */ -class ACE_Export ACE_Event_Handler_Handle_Timeout_Upcall - : private ACE_Copy_Disabled -{ -public: - /// Constructor. - ACE_Event_Handler_Handle_Timeout_Upcall (void); - - /// Destructor. - ~ACE_Event_Handler_Handle_Timeout_Upcall (void); - - /// This method is called when a timer is registered. - int registration (ACE_Timer_Queue &timer_queue, - ACE_Event_Handler *handler, - const void *arg); - - /// This method is called before the timer expires. - int preinvoke (ACE_Timer_Queue &timer_queue, - ACE_Event_Handler *handler, - const void *arg, - int recurring_timer, - const ACE_Time_Value &cur_time, - const void *&upcall_act); - - /// This method is called when the timer expires. - int timeout (ACE_Timer_Queue &timer_queue, - ACE_Event_Handler *handler, - const void *arg, - int recurring_timer, - const ACE_Time_Value &cur_time); - - /// This method is called after the timer expires. - int postinvoke (ACE_Timer_Queue &timer_queue, - ACE_Event_Handler *handler, - const void *arg, - int recurring_timer, - const ACE_Time_Value &cur_time, - const void *upcall_act); - - /// This method is called when a handler is cancelled - int cancel_type (ACE_Timer_Queue &timer_queue, - ACE_Event_Handler *handler, - int dont_call, - int &requires_reference_counting); - - /// This method is called when a timer is cancelled - int cancel_timer (ACE_Timer_Queue &timer_queue, - ACE_Event_Handler *handler, - int dont_call, - int requires_reference_counting); - - /// This method is called when the timer queue is destroyed and - /// the timer is still contained in it - int deletion (ACE_Timer_Queue &timer_queue, - ACE_Event_Handler *handler, - const void *arg); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - - /// Flag indicating that reference counting is required for this - /// event handler upcall. - int requires_reference_counting_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined(__ACE_INLINE__) -# include "ace/Event_Handler_Handle_Timeout_Upcall.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_EVENT_HANDLER_HANDLE_TIMEOUT_UPCALL_H */ diff --git a/deps/acelite/ace/Event_Handler_Handle_Timeout_Upcall.inl b/deps/acelite/ace/Event_Handler_Handle_Timeout_Upcall.inl deleted file mode 100644 index 8c0b41bb0..000000000 --- a/deps/acelite/ace/Event_Handler_Handle_Timeout_Upcall.inl +++ /dev/null @@ -1,69 +0,0 @@ -#include "ace/Event_Handler.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE int -ACE_Event_Handler_Handle_Timeout_Upcall:: -registration (ACE_Timer_Queue &, - ACE_Event_Handler *event_handler, - const void *) -{ - event_handler->add_reference (); - return 0; -} - -ACE_INLINE int -ACE_Event_Handler_Handle_Timeout_Upcall:: -preinvoke (ACE_Timer_Queue &, - ACE_Event_Handler *event_handler, - const void *, - int, - const ACE_Time_Value &, - const void * & upcall_act) -{ - bool const requires_reference_counting = - event_handler->reference_counting_policy ().value () == - ACE_Event_Handler::Reference_Counting_Policy::ENABLED; - - if (requires_reference_counting) - { - event_handler->add_reference (); - - upcall_act = &this->requires_reference_counting_; - } - - return 0; -} - -ACE_INLINE int -ACE_Event_Handler_Handle_Timeout_Upcall:: -postinvoke (ACE_Timer_Queue & /* timer_queue */, - ACE_Event_Handler *event_handler, - const void * /* timer_act */, - int /* recurring_timer */, - const ACE_Time_Value & /* cur_time */, - const void *upcall_act) -{ - if (upcall_act == &this->requires_reference_counting_) - { - event_handler->remove_reference (); - } - - return 0; -} - -ACE_INLINE int -ACE_Event_Handler_Handle_Timeout_Upcall:: -cancel_timer (ACE_Timer_Queue &, - ACE_Event_Handler *event_handler, - int, - int requires_reference_counting) -{ - if (requires_reference_counting) - event_handler->remove_reference (); - - return 0; -} - - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Event_Handler_T.cpp b/deps/acelite/ace/Event_Handler_T.cpp deleted file mode 100644 index 51efca891..000000000 --- a/deps/acelite/ace/Event_Handler_T.cpp +++ /dev/null @@ -1,118 +0,0 @@ -// Event_Handler_T.cpp -#ifndef ACE_EVENT_HANDLER_T_CPP -#define ACE_EVENT_HANDLER_T_CPP - -#include "ace/Event_Handler_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (__ACE_INLINE__) -#include "ace/Event_Handler_T.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Event_Handler_T) - -template void -ACE_Event_Handler_T::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Event_Handler_T::dump"); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Event_Handler_T::~ACE_Event_Handler_T (void) -{ - ACE_TRACE ("ACE_Event_Handler_T::~ACE_Event_Handler_T"); - if (this->delete_handler_) - delete this->op_handler_; -} - -template -ACE_Event_Handler_T::ACE_Event_Handler_T (T *op_handler, int delete_handler, - GET_HANDLE get_handle, - IO_HANDLER input_h, - CL_HANDLER close_h, - SIG_HANDLER sig_h, - TO_HANDLER timeout_h, - IO_HANDLER output_h, - SET_HANDLE set_handle, - IO_HANDLER except_h) - : op_handler_ (op_handler), - input_handler_ (input_h), - output_handler_ (output_h), - except_handler_ (except_h), - to_handler_ (timeout_h), - cl_handler_ (close_h), - sig_handler_ (sig_h), - delete_handler_ (delete_handler), - set_handle_ (set_handle), - get_handle_ (get_handle) -{ - ACE_TRACE ("ACE_Event_Handler_T::ACE_Event_Handler_T"); -} - -template ACE_HANDLE -ACE_Event_Handler_T::get_handle (void) const -{ - ACE_TRACE ("ACE_Event_Handler_T::get_handle"); - return this->get_handle_ == 0 ? ACE_INVALID_HANDLE : (this->op_handler_->*get_handle_) (); -} - -template void -ACE_Event_Handler_T::set_handle (ACE_HANDLE h) -{ - ACE_TRACE ("ACE_Event_Handler_T::set_handle"); - if (this->set_handle_ != 0) - (this->op_handler_->*set_handle_) (h); -} - -template int -ACE_Event_Handler_T::handle_input (ACE_HANDLE fd) -{ - ACE_TRACE ("ACE_Event_Handler_T::handle_input"); - return this->input_handler_ == 0 ? 0 : (this->op_handler_->*input_handler_) (fd); -} - -template int -ACE_Event_Handler_T::handle_output (ACE_HANDLE fd) -{ - ACE_TRACE ("ACE_Event_Handler_T::handle_output"); - return this->output_handler_ == 0 ? 0 : (this->op_handler_->*output_handler_) (fd); -} - -template int -ACE_Event_Handler_T::handle_exception (ACE_HANDLE fd) -{ - ACE_TRACE ("ACE_Event_Handler_T::handle_exception"); - return this->except_handler_ == 0 ? 0 : (this->op_handler_->*except_handler_) (fd); -} - -template int -ACE_Event_Handler_T::handle_timeout (const ACE_Time_Value &tv, const void *arg) -{ - ACE_TRACE ("ACE_Event_Handler_T::handle_timeout"); - return this->to_handler_ == 0 ? 0 : (this->op_handler_->*to_handler_) (tv, arg); -} - -template int -ACE_Event_Handler_T::handle_close (ACE_HANDLE fd, ACE_Reactor_Mask close_mask) -{ - ACE_TRACE ("ACE_Event_Handler_T::handle_close"); - return this->cl_handler_ == 0 ? 0 : (this->op_handler_->*cl_handler_) (fd, close_mask); -} - -template int -ACE_Event_Handler_T::handle_signal (int signum, siginfo_t *s, ucontext_t *u) -{ - ACE_TRACE ("ACE_Event_Handler_T::handle_signal"); - return this->sig_handler_ == 0 ? 0 : (this->op_handler_->*sig_handler_) (signum, s, u); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_EVENT_HANDLER_T_CPP */ diff --git a/deps/acelite/ace/Event_Handler_T.h b/deps/acelite/ace/Event_Handler_T.h deleted file mode 100644 index 979480947..000000000 --- a/deps/acelite/ace/Event_Handler_T.h +++ /dev/null @@ -1,185 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Event_Handler_T.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_EVENT_HANDLER_T_H -#define ACE_EVENT_HANDLER_T_H -#include /**/ "ace/pre.h" - -#include "ace/Event_Handler.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Event_Handler_T - * - * @brief Enable a class that doesn't inherit from the - * ACE_Event_Handler to be incorporated into the ACE_Reactor - * framework. Thanks to Greg Lavender (g.lavender@isode.com) - * for sharing this idea. - * - * It is sometimes the case that an application has a hierarchy - * of operation dispatcher classes that have their own - * inheritance hierarchy but also would like to integrate with - * the ACE_Reactor. Rather than adopt a "mixin" approach, it is - * often cleaner to define a template as a subclass of - * ACE_Event_Handler and parameterize it with an operation - * dispatcher type. - * When constructing an instantiation of the ACE_Event_Handler_T - * object, a set of pointers to member functions must be - * provided so that when one of the handle_* methods is called - * by the ACE_Reactor, the appropriate method is called on the - * underlying operations object. This is done since in some - * cases it is useful to map any event that happens to the same - * method on an object. - * The ACE_Event_Handler_T template is instantiated by an - * operations object and registered with the ACE_Reactor, and it - * then calls the appropriate op_handler. So, it's basically - * just another level of indirection in event dispatching. The - * coupling betweent the ultimate handler of the event and the - * ACE_Event_Handler class is relaxed a bit by have this - * intermediate object of type around. The - * client object can then dynamically change the bindings for - * the various handlers so that during the life of one of the - * operation objects, it can change how it wants events to be - * handled. It just instantiates a new instance of the template - * with different bindings and reregisters this new object with - * the ACE_Reactor. - */ -template -class ACE_Event_Handler_T : public ACE_Event_Handler -{ -public: - // = Typedefs to simplify pointer-to-member-function registration. - - // Get/set the underlying handle. - typedef ACE_HANDLE (T::*GET_HANDLE) (void) const; - typedef void (T::*SET_HANDLE) (ACE_HANDLE); - - /// Handle I/O events. - typedef int (T::*IO_HANDLER) (ACE_HANDLE); - - /// Handle timeout events. - typedef int (T::*TO_HANDLER) (const ACE_Time_Value &, const void *); - - /// Handle close events. - typedef int (T::*CL_HANDLER) (ACE_HANDLE, ACE_Reactor_Mask); - - typedef int (T::*SIG_HANDLER) (int, siginfo_t*, ucontext_t*); - - /// Initialize the op_handler. - ACE_Event_Handler_T (T *op_handler, - int delete_handler, - GET_HANDLE get_handle = 0, - IO_HANDLER input = 0, - CL_HANDLER close = 0, - SIG_HANDLER sig = 0, - TO_HANDLER timeout = 0, - IO_HANDLER output = 0, - SET_HANDLE set_handle = 0, - IO_HANDLER except = 0); - - /// Close down and delete the - ~ACE_Event_Handler_T (void); - - // = Override all the ACE_Event_Handler methods. - - // These methods all delegate down to the operations handler. - virtual ACE_HANDLE get_handle (void) const; - virtual void set_handle (ACE_HANDLE); - virtual int handle_input (ACE_HANDLE fd = ACE_INVALID_HANDLE); - virtual int handle_output (ACE_HANDLE fd = ACE_INVALID_HANDLE); - virtual int handle_exception (ACE_HANDLE fd = ACE_INVALID_HANDLE); - virtual int handle_timeout (const ACE_Time_Value &tv, const void *arg = 0); - virtual int handle_close (ACE_HANDLE fd, ACE_Reactor_Mask close_mask); - virtual int handle_signal (int signum, siginfo_t * = 0, ucontext_t * = 0); - - // = Get/set the operations handler. - T *op_handler (void); - void op_handler (T *); - - // = Get/set the target pointer-to-method used for dispatching. - - GET_HANDLE handle_get (void); - void handle_get (GET_HANDLE); - - SET_HANDLE handle_set (void); - void handle_set (SET_HANDLE); - - IO_HANDLER input_handler (void); - void input_handler (IO_HANDLER); - - IO_HANDLER output_handler (void); - void output_handler (IO_HANDLER); - - IO_HANDLER except_handler (void); - void except_handler (IO_HANDLER); - - TO_HANDLER to_handler (void); - void to_handler (TO_HANDLER); - - CL_HANDLER cl_handler (void); - void cl_handler (CL_HANDLER); - - SIG_HANDLER sig_handler (void); - void sig_handler (SIG_HANDLER); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Pointer to the object that handles all the delegated operations. - T *op_handler_; - - // = Handle input, output, and exception events. - IO_HANDLER input_handler_; - IO_HANDLER output_handler_; - IO_HANDLER except_handler_; - - /// Handle timeout events. - TO_HANDLER to_handler_; - - /// Handle close events. - CL_HANDLER cl_handler_; - - /// Handle signal events. - SIG_HANDLER sig_handler_; - - /// Keeps track of whether we need to delete the handler in the - /// destructor. - int delete_handler_; - - // = Get/set underlying handle. - SET_HANDLE set_handle_; - GET_HANDLE get_handle_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Event_Handler_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Event_Handler_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Event_Handler_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_EVENT_HANDLER_H */ diff --git a/deps/acelite/ace/Event_Handler_T.inl b/deps/acelite/ace/Event_Handler_T.inl deleted file mode 100644 index 64df02a1d..000000000 --- a/deps/acelite/ace/Event_Handler_T.inl +++ /dev/null @@ -1,132 +0,0 @@ -// -*- C++ -*- -#include "ace/Global_Macros.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE void -ACE_Event_Handler_T::op_handler (T *op) -{ - ACE_TRACE ("ACE_Event_Handler_T::op_handler"); - this->op_handler_ = op; -} - -template ACE_INLINE T * -ACE_Event_Handler_T::op_handler (void) -{ - ACE_TRACE ("ACE_Event_Handler_T::op_handler"); - return this->op_handler_; -} - -template ACE_INLINE typename ACE_Event_Handler_T::GET_HANDLE -ACE_Event_Handler_T::handle_get (void) -{ - ACE_TRACE ("ACE_Event_Handler_T::handle_get"); - return this->get_handle_; -} - -template ACE_INLINE void -ACE_Event_Handler_T::handle_get (typename ACE_Event_Handler_T::GET_HANDLE h) -{ - ACE_TRACE ("ACE_Event_Handler_T::handle_get"); - this->get_handle_ = h; -} - -template ACE_INLINE typename ACE_Event_Handler_T::SET_HANDLE -ACE_Event_Handler_T::handle_set (void) -{ - ACE_TRACE ("ACE_Event_Handler_T::handle_set"); - return this->set_handle_; -} - -template ACE_INLINE void -ACE_Event_Handler_T::handle_set (typename ACE_Event_Handler_T::SET_HANDLE h) -{ - ACE_TRACE ("ACE_Event_Handler_T::handle_set"); - this->set_handle_ = h; -} - -template ACE_INLINE typename ACE_Event_Handler_T::IO_HANDLER -ACE_Event_Handler_T::input_handler (void) -{ - ACE_TRACE ("ACE_Event_Handler_T::input_handler"); - return this->input_handler_; -} - -template ACE_INLINE void -ACE_Event_Handler_T::input_handler (typename ACE_Event_Handler_T::IO_HANDLER h) -{ - ACE_TRACE ("ACE_Event_Handler_T::input_handler"); - this->input_handler_ = h; -} - -template ACE_INLINE typename ACE_Event_Handler_T::IO_HANDLER -ACE_Event_Handler_T::output_handler (void) -{ - ACE_TRACE ("ACE_Event_Handler_T::output_handler"); - return this->output_handler_; -} - -template ACE_INLINE void -ACE_Event_Handler_T::output_handler (typename ACE_Event_Handler_T::IO_HANDLER h) -{ - ACE_TRACE ("ACE_Event_Handler_T::output_handler"); - this->output_handler_ = h; -} - -template ACE_INLINE typename ACE_Event_Handler_T::IO_HANDLER -ACE_Event_Handler_T::except_handler (void) -{ - ACE_TRACE ("ACE_Event_Handler_T::except_handler"); - return this->except_handler_; -} - -template ACE_INLINE void -ACE_Event_Handler_T::except_handler (typename ACE_Event_Handler_T::IO_HANDLER h) -{ - ACE_TRACE ("ACE_Event_Handler_T::except_handler"); - this->except_handler_ = h; -} - -template ACE_INLINE typename ACE_Event_Handler_T::TO_HANDLER -ACE_Event_Handler_T::to_handler (void) -{ - ACE_TRACE ("ACE_Event_Handler_T::to_handler"); - return this->to_handler_; -} - -template ACE_INLINE void -ACE_Event_Handler_T::to_handler (typename ACE_Event_Handler_T::TO_HANDLER h) -{ - ACE_TRACE ("ACE_Event_Handler_T::to_handler"); - this->to_handler_ = h; -} - -template ACE_INLINE typename ACE_Event_Handler_T::CL_HANDLER -ACE_Event_Handler_T::cl_handler (void) -{ - ACE_TRACE ("ACE_Event_Handler_T::cl_handler"); - return this->cl_handler_; -} - -template ACE_INLINE void -ACE_Event_Handler_T::cl_handler (typename ACE_Event_Handler_T::CL_HANDLER h) -{ - ACE_TRACE ("ACE_Event_Handler_T::cl_handler"); - this->cl_handler_ = h; -} - -template ACE_INLINE typename ACE_Event_Handler_T::SIG_HANDLER -ACE_Event_Handler_T::sig_handler (void) -{ - ACE_TRACE ("ACE_Event_Handler_T::sig_handler"); - return this->sig_handler_; -} - -template ACE_INLINE void -ACE_Event_Handler_T::sig_handler (typename ACE_Event_Handler_T::SIG_HANDLER h) -{ - ACE_TRACE ("ACE_Event_Handler_T::sig_handler"); - this->sig_handler_ = h; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FIFO.cpp b/deps/acelite/ace/FIFO.cpp deleted file mode 100644 index e598bb636..000000000 --- a/deps/acelite/ace/FIFO.cpp +++ /dev/null @@ -1,77 +0,0 @@ -#include "ace/FIFO.h" - -#if !defined (__ACE_INLINE__) -#include "ace/FIFO.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Log_Category.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_NS_errno.h" -#include "ace/OS_NS_sys_stat.h" -#include "ace/OS_NS_fcntl.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_FIFO) - -void -ACE_FIFO::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_FIFO::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("rendezvous_ = %s"), this->rendezvous_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -int -ACE_FIFO::open (const ACE_TCHAR *r, int flags, mode_t perms, - LPSECURITY_ATTRIBUTES sa) -{ - ACE_TRACE ("ACE_FIFO::open"); - ACE_OS::strsncpy (this->rendezvous_, r, MAXPATHLEN); - - if ((flags & O_CREAT) != 0 - && ACE_OS::mkfifo (this->rendezvous_, perms) == -1 - && !(errno == EEXIST)) - return -1; - - this->set_handle (ACE_OS::open (this->rendezvous_, flags, 0, sa)); - return this->get_handle () == ACE_INVALID_HANDLE ? -1 : 0; -} - -ACE_FIFO::ACE_FIFO (const ACE_TCHAR *fifo_name, - int flags, - mode_t perms, - LPSECURITY_ATTRIBUTES sa) -{ - ACE_TRACE ("ACE_FIFO::ACE_FIFO"); - if (this->open (fifo_name, flags, perms, sa) == -1) - ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE_FIFO"))); -} - -ACE_FIFO::ACE_FIFO (void) -{ -// ACE_TRACE ("ACE_FIFO::ACE_FIFO"); -} - -int -ACE_FIFO::close (void) -{ - ACE_TRACE ("ACE_FIFO::close"); - int result = 0; - - if (this->get_handle () != ACE_INVALID_HANDLE) - { - result = ACE_OS::close (this->get_handle ()); - this->set_handle (ACE_INVALID_HANDLE); - } - return result; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FIFO.h b/deps/acelite/ace/FIFO.h deleted file mode 100644 index 2c66ab10f..000000000 --- a/deps/acelite/ace/FIFO.h +++ /dev/null @@ -1,97 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file FIFO.h - * - * @author Doug Schmidt - */ -//========================================================================== - - -#ifndef ACE_FIFO_H -#define ACE_FIFO_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/IPC_SAP.h" -#include "ace/os_include/os_limits.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_FIFO - * - * @brief Abstract base class for UNIX FIFOs - * - * UNIX FIFOs are also known Named Pipes, which are totally - * unrelated to Windows Named Pipes. If you want to use a local - * IPC mechanism that will be portable to both UNIX and Windows, - * take a look at the ACE_Pipe or ACE_SPIPE_Stream classes. - */ -class ACE_Export ACE_FIFO : public ACE_IPC_SAP -{ -public: - /** - * Open up the named pipe (FIFO) on the @a rendezvous point in accordance - * with the @a flags. - * - * If @a flags contains @c O_CREAT open() will attempt to call mkfifo() - * to create the FIFO before opening it. In this case, this method - * will not fail simply because the fifo already exists. - * - * @retval 0 for success - * @retval -1 for error; errno contains the error code. - */ - int open (const ACE_TCHAR *rendezvous, int flags, mode_t perms, - LPSECURITY_ATTRIBUTES sa = 0); - - /// Close down the ACE_FIFO without removing the rendezvous point. - int close (void); - - /// Close down the ACE_FIFO and remove the rendezvous point from the - /// file system. - int remove (void); - - /// Return the local address of this endpoint. - int get_local_addr (const ACE_TCHAR *&rendezvous) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /** - * Protected constructors ensure this class cannot be used directly. - * User code must use ACE_FIFO_Send and/or ACE_FIFO_Recv. - */ - //@{ - /// Default constructor. - ACE_FIFO (void); - - /// Open up the named pipe on the @a rendezvous in accordance with the - /// flags. - ACE_FIFO (const ACE_TCHAR *rendezvous, int flags, mode_t perms, - LPSECURITY_ATTRIBUTES sa = 0); - //@} - -private: - /// Rendezvous point in the file system. - ACE_TCHAR rendezvous_[MAXPATHLEN + 1]; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/FIFO.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_FIFO_H */ diff --git a/deps/acelite/ace/FIFO.inl b/deps/acelite/ace/FIFO.inl deleted file mode 100644 index 9fe5c733e..000000000 --- a/deps/acelite/ace/FIFO.inl +++ /dev/null @@ -1,22 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_unistd.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE int -ACE_FIFO::get_local_addr (const ACE_TCHAR *&r) const -{ - ACE_TRACE ("ACE_FIFO::get_local_addr"); - r = this->rendezvous_; - return 0; -} - -ACE_INLINE int -ACE_FIFO::remove (void) -{ - ACE_TRACE ("ACE_FIFO::remove"); - int const result = this->close (); - return ACE_OS::unlink (this->rendezvous_) == -1 || result == -1 ? -1 : 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FIFO_Recv.cpp b/deps/acelite/ace/FIFO_Recv.cpp deleted file mode 100644 index bb5568d56..000000000 --- a/deps/acelite/ace/FIFO_Recv.cpp +++ /dev/null @@ -1,89 +0,0 @@ -#include "ace/FIFO_Recv.h" -#include "ace/Log_Category.h" -#include "ace/OS_NS_fcntl.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/FIFO_Recv.inl" -#endif /* __ACE_INLINE__ */ - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_FIFO_Recv) - -void -ACE_FIFO_Recv::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_FIFO_Recv::dump"); - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACE_FIFO::dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("aux_handle_ = %d"), this->aux_handle_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -int -ACE_FIFO_Recv::close (void) -{ - ACE_TRACE ("ACE_FIFO_Recv::close"); - int result = ACE_FIFO::close (); - - if (this->aux_handle_ != ACE_INVALID_HANDLE) - return ACE_OS::close (this->aux_handle_); - else - return result; -} - -// Note that persistent means "open fifo for writing, as well as -// reading." This ensures that the fifo never gets EOF, even if there -// aren't any writers at the moment! - -int -ACE_FIFO_Recv::open (const ACE_TCHAR *fifo_name, - int flags, - mode_t perms, - int persistent, - LPSECURITY_ATTRIBUTES sa) -{ - ACE_TRACE ("ACE_FIFO_Recv::open"); - - if (ACE_FIFO::open (fifo_name, ACE_NONBLOCK | flags, perms, sa) == -1) - return -1; - else if (this->disable (ACE_NONBLOCK) == -1) - return -1; - else if (persistent - && (this->aux_handle_ = ACE_OS::open (fifo_name, O_WRONLY, 0, sa)) == ACE_INVALID_HANDLE) - return -1; - else - return this->get_handle () == ACE_INVALID_HANDLE ? -1 : 0; -} - -ACE_FIFO_Recv::ACE_FIFO_Recv (void) - : aux_handle_ (ACE_INVALID_HANDLE) -{ - ACE_TRACE ("ACE_FIFO_Recv::ACE_FIFO_Recv"); -} - -ACE_FIFO_Recv::ACE_FIFO_Recv (const ACE_TCHAR *fifo_name, - int flags, - mode_t perms, - int persistent, - LPSECURITY_ATTRIBUTES sa) - : aux_handle_ (ACE_INVALID_HANDLE) -{ - ACE_TRACE ("ACE_FIFO_Recv::ACE_FIFO_Recv"); - - if (this->ACE_FIFO_Recv::open (fifo_name, - flags, - perms, - persistent, - sa) == -1) - ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE_FIFO_Recv"))); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FIFO_Recv.h b/deps/acelite/ace/FIFO_Recv.h deleted file mode 100644 index bf3c9a8d2..000000000 --- a/deps/acelite/ace/FIFO_Recv.h +++ /dev/null @@ -1,94 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file FIFO_Recv.h - * - * @author Doug Schmidt - */ -//========================================================================== - - -#ifndef ACE_FIFO_RECV_H -#define ACE_FIFO_RECV_H - -#include /**/ "ace/pre.h" - -#include "ace/FIFO.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/os_include/os_fcntl.h" -#include "ace/Default_Constants.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_FIFO_Recv - * - * @brief Receiver side of the bytestream C++ wrapper for UNIX - * FIFOs. - */ -class ACE_Export ACE_FIFO_Recv : public ACE_FIFO -{ -public: - /// @name Initialization methods. - /// - /// Note that @c ACE_NONBLOCK will be added to any @a flags value passed. - /// This causes the open to succeed even if no writer has yet opened the - /// fifo. There is no way to disable this behavior. - /// - /// @arg persistent Means "open fifo for writing, as well as - /// reading." This ensures that the fifo never gets EOF, even if there - /// aren't any writers at the moment! - //@{ - - /// Default constructor. - ACE_FIFO_Recv (void); - - /// Open up a bytestream named pipe for reading. - ACE_FIFO_Recv (const ACE_TCHAR *rendezvous, - int flags = O_CREAT | O_RDONLY, - mode_t perms = ACE_DEFAULT_FILE_PERMS, - int persistent = 1, - LPSECURITY_ATTRIBUTES sa = 0); - - /// Open up a bytestream named pipe for reading. - int open (const ACE_TCHAR *rendezvous, - int flags = O_CREAT | O_RDONLY, - mode_t perms = ACE_DEFAULT_FILE_PERMS, - int persistent = 1, - LPSECURITY_ATTRIBUTES sa = 0); - //@} - - /// Close down the fifo. - int close (void); - - /// Recv @a buf of up to @a len bytes. - ssize_t recv (void *buf, size_t len); - - /// Recv @a buf of exactly @a len bytes (block until done). - ssize_t recv_n (void *buf, size_t len); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Auxiliary handle that is used to implement persistent FIFOs. - ACE_HANDLE aux_handle_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/FIFO_Recv.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* ACE_FIFO_RECV_H */ diff --git a/deps/acelite/ace/FIFO_Recv.inl b/deps/acelite/ace/FIFO_Recv.inl deleted file mode 100644 index aa95234c5..000000000 --- a/deps/acelite/ace/FIFO_Recv.inl +++ /dev/null @@ -1,21 +0,0 @@ -// -*- C++ -*- -#include "ace/ACE.h" -#include "ace/OS_NS_unistd.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE ssize_t -ACE_FIFO_Recv::recv (void *buf, size_t len) -{ - ACE_TRACE ("ACE_FIFO_Recv::recv"); - return ACE_OS::read (this->get_handle (), (char *) buf, len); -} - -ACE_INLINE ssize_t -ACE_FIFO_Recv::recv_n (void *buf, size_t n) -{ - ACE_TRACE ("ACE_FIFO_Recv::recv_n"); - return ACE::recv_n (this->get_handle (), buf, n); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FIFO_Recv_Msg.cpp b/deps/acelite/ace/FIFO_Recv_Msg.cpp deleted file mode 100644 index 494f098ac..000000000 --- a/deps/acelite/ace/FIFO_Recv_Msg.cpp +++ /dev/null @@ -1,66 +0,0 @@ -#include "ace/FIFO_Recv_Msg.h" - -#include "ace/Log_Category.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/FIFO_Recv_Msg.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_FIFO_Recv_Msg) - -void -ACE_FIFO_Recv_Msg::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_FIFO_Recv_Msg::dump"); - ACE_FIFO_Recv::dump (); -#endif /* ACE_HAS_DUMP */ -} - -// Note that persistent means "open FIFO for writing, as well as -// reading." This ensures that the FIFO never gets EOF, even if there -// aren't any writers at the moment! - -int -ACE_FIFO_Recv_Msg::open (const ACE_TCHAR *fifo_name, - int flags, - mode_t perms, - int persistent, - LPSECURITY_ATTRIBUTES sa) -{ - ACE_TRACE ("ACE_FIFO_Recv_Msg::open"); - - return ACE_FIFO_Recv::open (fifo_name, - flags, - perms, - persistent, - sa); -} - -ACE_FIFO_Recv_Msg::ACE_FIFO_Recv_Msg (void) -{ - ACE_TRACE ("ACE_FIFO_Recv_Msg::ACE_FIFO_Recv_Msg"); -} - -ACE_FIFO_Recv_Msg::ACE_FIFO_Recv_Msg (const ACE_TCHAR *fifo_name, - int flags, - mode_t perms, - int persistent, - LPSECURITY_ATTRIBUTES sa) -{ - ACE_TRACE ("ACE_FIFO_Recv_Msg::ACE_FIFO_Recv_Msg"); - - if (this->ACE_FIFO_Recv_Msg::open (fifo_name, - flags, - perms, - persistent, - sa) == -1) - ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE_FIFO_Recv_Msg"))); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FIFO_Recv_Msg.h b/deps/acelite/ace/FIFO_Recv_Msg.h deleted file mode 100644 index 803702ebc..000000000 --- a/deps/acelite/ace/FIFO_Recv_Msg.h +++ /dev/null @@ -1,135 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file FIFO_Recv_Msg.h - * - * @author Doug Schmidt - */ -//============================================================================= - - -#ifndef ACE_FIFO_RECV_MSG_H -#define ACE_FIFO_RECV_MSG_H -#include /**/ "ace/pre.h" - -#include "ace/FIFO_Recv.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward decls -class ACE_Str_Buf; - -/** - * @class ACE_FIFO_Recv_Msg - * - * @brief Receiver side for the record oriented C++ wrapper for UNIX FIFOs. - * - * This method works slightly differently on platforms with the - * @c ACE_HAS_STREAM_PIPES configuration setting than those without. - * With ACE_HAS_STREAM_PIPES, the @c getmsg() system function is used - * and it preserves message boundaries internally. Without - * @c ACE_HAS_STREAM_PIPES, the message boundaries are emulated by - * this class and ACE_FIFO_Send_Msg cooperating. The sending class - * first writes an integer number of bytes in the message, then the - * message. ACE_FIFO_Recv_Msg reads the count, then the data. - * The operational differences occur primarily when a message is larger - * than what a caller of this class requests. See recv() for details. - */ -class ACE_Export ACE_FIFO_Recv_Msg : public ACE_FIFO_Recv -{ -public: - /// Default constructor. - ACE_FIFO_Recv_Msg (void); - - /// Open up a record-oriented named pipe for reading. - ACE_FIFO_Recv_Msg (const ACE_TCHAR *rendezvous, - int flags = O_CREAT | O_RDONLY, - mode_t perms = ACE_DEFAULT_FILE_PERMS, - int persistent = 1, - LPSECURITY_ATTRIBUTES sa = 0); - - /// Open up a record-oriented named pipe for reading. - int open (const ACE_TCHAR *rendezvous, - int flags = O_CREAT | O_RDONLY, - mode_t perms = ACE_DEFAULT_FILE_PERMS, - int persistent = 1, - LPSECURITY_ATTRIBUTES sa = 0); - - /// Receive a message based on attributes in an ACE_Str_Buf. - /** - * @param msg Reference to an ACE_Str_Buf whose @c buf member points - * to the memory to receive the data and @c maxlen member - * contains the maximum number of bytes to receive. - * On return after successfully reading data, the - * @c len member contains the number of bytes received and - * placed in the buffer pointed to by @c msg.buf. - * - * @retval -1 Error; consult @c errno for specific error number. - * @return If the @c ACE_HAS_STREAM_PIPES configuration setting is - * defined, the return value is the number of bytes received - * in the message and will be the same as @c buf.len. - * The return value from the @c getmsg() system function - * is discarded. - * If @c ACE_HAS_STREAM_PIPES is not defined, the number - * of bytes in the message read from the FIFO is returned. - * If the message is larger than the maximum length - * requested in @c msg.maxlen, the return value reflects - * the entire message length, and the @c msg.len member - * reflects how many bytes were actually placed in the - * caller's buffer. Any part of the message longer than - * @c msg.maxlen is discarded. - */ - ssize_t recv (ACE_Str_Buf &msg); - - /// Receive a message based on buffer pointer and maximum size. - /** - * @param buf Pointer to the memory to receive the data. - * @param len The maximum number of bytes to receive. - * - * @retval -1 Error; consult @c errno for specific error number. - * @return The number of bytes received in the message. For messages - * that are larger than the requested maximum size, the - * behavior is different depending on the @c ACE_HAS_STREAM_PIPES - * configuration setting. With @c ACE_HAS_STREAM_PIPES, - * the return value will be the same as @arg len (this is - * also possible if the message is exactly the same length - * as @arg len, and the two cases are indistinguishable). - * Without @c ACE_HAS_STREAM_PIPES, the return value is - * the total length of the message, including bytes in - * excess of @arg len. The excess bytes are discarded. - */ - ssize_t recv (void *buf, size_t len); - -#if defined (ACE_HAS_STREAM_PIPES) - /// Recv @a data and @a cntl message via Stream pipes. - ssize_t recv (ACE_Str_Buf *data, - ACE_Str_Buf *cntl, - int *flags); - - /// Recv @a data and @a cntl message via Stream pipes in "band" mode. - ssize_t recv (int *band, - ACE_Str_Buf *data, - ACE_Str_Buf *cntl, - int *flags); -#endif /* ACE_HAS_STREAM_PIPES */ - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/FIFO_Recv_Msg.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_FIFO_RECV_MSG_H */ diff --git a/deps/acelite/ace/FIFO_Recv_Msg.inl b/deps/acelite/ace/FIFO_Recv_Msg.inl deleted file mode 100644 index 917aee9df..000000000 --- a/deps/acelite/ace/FIFO_Recv_Msg.inl +++ /dev/null @@ -1,134 +0,0 @@ -// -*- C++ -*- -#include "ace/Min_Max.h" -#include "ace/OS_NS_stropts.h" -#include "ace/Truncate.h" - -#if !defined (ACE_HAS_STREAM_PIPES) -#include "ace/OS_NS_unistd.h" -#endif - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE ssize_t -ACE_FIFO_Recv_Msg::recv (ACE_Str_Buf &recv_msg) -{ - ACE_TRACE ("ACE_FIFO_Recv_Msg::recv"); -#if defined (ACE_HAS_STREAM_PIPES) - int i = 0; - if (ACE_OS::getmsg (this->get_handle (), - (strbuf *) 0, - (strbuf *) &recv_msg, - &i) == -1) - { - return -1; - } - else - { - return recv_msg.len; - } -#else /* Do the ol' 2-read trick... */ - if (ACE_OS::read (this->get_handle (), - (char *) &recv_msg.len, - sizeof recv_msg.len) != (ssize_t) sizeof recv_msg.len) - { - return -1; - } - else - { - size_t remaining = static_cast (recv_msg.len); - size_t requested = static_cast (recv_msg.maxlen); - ssize_t recv_len = ACE_OS::read (this->get_handle (), - (char *) recv_msg.buf, - ACE_MIN (remaining, requested)); - - if (recv_len == -1) - { - return -1; - } - - // Tell caller what's really in the buffer. - recv_msg.len = static_cast (recv_len); - - // If there are more bytes remaining in the message, read them and - // throw them away. Leaving them in the FIFO would make it difficult - // to find the start of the next message in the fifo. - // Since the ACE_HAS_STREAM_PIPES version of this method doesn't - // return getmsg()'s indication of "data remaining", don't worry about - // saving the indication here either to read the remainder later. - size_t total_msg_size = remaining; - remaining -= recv_len; - - while (remaining > 0) - { - const size_t throw_away = 1024; - char dev_null[throw_away]; - recv_len = ACE_OS::read (this->get_handle (), - dev_null, - ACE_MIN (remaining, throw_away)); - - if (recv_len == -1) - { - break; - } - - remaining -= recv_len; - } - - return ACE_Utils::truncate_cast (total_msg_size); - } -#endif /* ACE_HAS_STREAM_PIPES */ -} - -ACE_INLINE ssize_t -ACE_FIFO_Recv_Msg::recv (void *buf, size_t max_len) -{ - ACE_TRACE ("ACE_FIFO_Recv_Msg::recv"); - ACE_Str_Buf recv_msg ((char *) buf, 0, static_cast (max_len)); - - return this->recv (recv_msg); -} - -#if defined (ACE_HAS_STREAM_PIPES) -ACE_INLINE ssize_t -ACE_FIFO_Recv_Msg::recv (ACE_Str_Buf *data, - ACE_Str_Buf *cntl, - int *flags) -{ - ACE_TRACE ("ACE_FIFO_Recv_Msg::recv"); - if (ACE_OS::getmsg (this->get_handle (), - (strbuf *) cntl, - (strbuf *) data, - flags) == -1) - { - return -1; - } - else - { - return (cntl == 0 ? 0 : cntl->len) + (data == 0 ? 0 : data->len); - } -} - -ACE_INLINE ssize_t -ACE_FIFO_Recv_Msg::recv (int *band, - ACE_Str_Buf *data, - ACE_Str_Buf *cntl, - int *flags) -{ - ACE_TRACE ("ACE_FIFO_Recv_Msg::recv"); - - if (ACE_OS::getpmsg (this->get_handle (), - (strbuf *) cntl, - (strbuf *) data, - band, - flags) == -1) - { - return -1; - } - else - { - return (cntl == 0 ? 0 : cntl->len) + (data == 0 ? 0 : data->len); - } -} -#endif /* ACE_HAS_STREAM_PIPES */ - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FIFO_Send.cpp b/deps/acelite/ace/FIFO_Send.cpp deleted file mode 100644 index 0c37b917e..000000000 --- a/deps/acelite/ace/FIFO_Send.cpp +++ /dev/null @@ -1,59 +0,0 @@ -#include "ace/FIFO_Send.h" -#include "ace/Log_Category.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/FIFO_Send.inl" -#endif /* __ACE_INLINE__ */ - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_FIFO_Send) - -void -ACE_FIFO_Send::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_FIFO_Send::dump"); - ACE_FIFO::dump (); -#endif /* ACE_HAS_DUMP */ -} - -ACE_FIFO_Send::ACE_FIFO_Send (void) -{ -// ACE_TRACE ("ACE_FIFO_Send::ACE_FIFO_Send"); -} - -int -ACE_FIFO_Send::open (const ACE_TCHAR *rendezvous_name, - int flags, - mode_t perms, - LPSECURITY_ATTRIBUTES sa) -{ - ACE_TRACE ("ACE_FIFO_Send::open"); - return ACE_FIFO::open (rendezvous_name, - flags | O_WRONLY, - perms, - sa); -} - -ACE_FIFO_Send::ACE_FIFO_Send (const ACE_TCHAR *fifo_name, - int flags, - mode_t perms, - LPSECURITY_ATTRIBUTES sa) -{ - ACE_TRACE ("ACE_FIFO_Send::ACE_FIFO_Send"); - if (this->ACE_FIFO_Send::open (fifo_name, - flags, - perms, - sa) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_FIFO_Send::ACE_FIFO_Send"))); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FIFO_Send.h b/deps/acelite/ace/FIFO_Send.h deleted file mode 100644 index 4c885df4b..000000000 --- a/deps/acelite/ace/FIFO_Send.h +++ /dev/null @@ -1,78 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file FIFO_Send.h - * - * @author Doug Schmidt - */ -//========================================================================== - -#ifndef ACE_FIFO_SEND_H -#define ACE_FIFO_SEND_H - -#include /**/ "ace/pre.h" - -#include "ace/FIFO.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/os_include/os_fcntl.h" -#include "ace/Default_Constants.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_FIFO_Send - * - * @brief Sender side for the bytestream C++ wrapper for UNIX FIFOs - */ -class ACE_Export ACE_FIFO_Send : public ACE_FIFO -{ -public: - /// @name Initialization methods. - /// - /// Note that @c O_WRONLY will be added to any @a flags value passed. - /// Default behavior is to block until a receiver also opens the fifo. - /// To use non-blocking behavior include ACE_NONBLOCK in @a flags. - //@{ - /// Default constructor. - ACE_FIFO_Send (void); - - /// Open up a bytestream named pipe for writing. - ACE_FIFO_Send (const ACE_TCHAR *rendezvous, - int flags = O_WRONLY, - mode_t perms = ACE_DEFAULT_FILE_PERMS, - LPSECURITY_ATTRIBUTES sa = 0); - - /// Open up a bytestream named pipe for writing. - int open (const ACE_TCHAR *rendezvous, - int flags = O_WRONLY, - mode_t perms = ACE_DEFAULT_FILE_PERMS, - LPSECURITY_ATTRIBUTES sa = 0); - //@} - - /// Send @a buf of up to @a len bytes. - ssize_t send (const void *buf, size_t len); - - /// Send @a buf of exactly @a len bytes (block until done). - ssize_t send_n (const void *buf, size_t len); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/FIFO_Send.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* ACE_FIFO_SEND_H */ diff --git a/deps/acelite/ace/FIFO_Send.inl b/deps/acelite/ace/FIFO_Send.inl deleted file mode 100644 index ee0d8d0b5..000000000 --- a/deps/acelite/ace/FIFO_Send.inl +++ /dev/null @@ -1,21 +0,0 @@ -// -*- C++ -*- -#include "ace/ACE.h" -#include "ace/OS_NS_unistd.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE ssize_t -ACE_FIFO_Send::send (const void *buf, size_t len) -{ - ACE_TRACE ("ACE_FIFO_Send::send"); - return ACE_OS::write (this->get_handle (), (const char *) buf, len); -} - -ACE_INLINE ssize_t -ACE_FIFO_Send::send_n (const void *buf, size_t n) -{ - ACE_TRACE ("ACE_FIFO_Send::send_n"); - return ACE::send_n (this->get_handle (), buf, n); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FIFO_Send_Msg.cpp b/deps/acelite/ace/FIFO_Send_Msg.cpp deleted file mode 100644 index 756a570f2..000000000 --- a/deps/acelite/ace/FIFO_Send_Msg.cpp +++ /dev/null @@ -1,81 +0,0 @@ -#include "ace/FIFO_Send_Msg.h" - -#include "ace/Log_Category.h" -#include "ace/OS_NS_sys_uio.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/FIFO_Send_Msg.inl" -#endif /* __ACE_INLINE__ */ - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_FIFO_Send_Msg) - -void -ACE_FIFO_Send_Msg::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_FIFO_Send_Msg::dump"); - ACE_FIFO_Send::dump (); -#endif /* ACE_HAS_DUMP */ -} - -ssize_t -ACE_FIFO_Send_Msg::send (const ACE_Str_Buf &send_msg) -{ - // ACE_TRACE ("ACE_FIFO_Send_Msg::send"); -#if defined (ACE_HAS_STREAM_PIPES) - if (ACE_OS::putmsg (this->get_handle (), - (strbuf *) 0, - (strbuf *) &send_msg, - 0) == -1) - return -1; - else - return send_msg.len; -#else - iovec iov[2]; - - iov[0].iov_base = (char *) &send_msg.len; - iov[0].iov_len = sizeof send_msg.len; - - iov[1].iov_base = (char *) send_msg.buf; - iov[1].iov_len = static_cast (send_msg.len); - - ssize_t sent = ACE_OS::writev (this->get_handle (), iov, 2); - if (sent > 0) - sent -= iov[0].iov_len; // Don't count the length we added. - return sent; -#endif /* ACE_HAS_STREAM_PIPES */ -} - -ACE_FIFO_Send_Msg::ACE_FIFO_Send_Msg (void) -{ -// ACE_TRACE ("ACE_FIFO_Send_Msg::ACE_FIFO_Send_Msg"); -} - -int -ACE_FIFO_Send_Msg::open (const ACE_TCHAR *fifo_name, - int flags, - mode_t perms, - LPSECURITY_ATTRIBUTES sa) -{ - ACE_TRACE ("ACE_FIFO_Send_Msg::open"); - return ACE_FIFO_Send::open (fifo_name, flags | O_WRONLY, perms, sa); -} - -ACE_FIFO_Send_Msg::ACE_FIFO_Send_Msg (const ACE_TCHAR *fifo_name, - int flags, - mode_t perms, - LPSECURITY_ATTRIBUTES sa) -{ - ACE_TRACE ("ACE_FIFO_Send_Msg::ACE_FIFO_Send_Msg"); - if (this->ACE_FIFO_Send_Msg::open (fifo_name, flags, perms, sa) == -1) - ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p\n"), ACE_TEXT ("ACE_FIFO_Send_Msg"))); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FIFO_Send_Msg.h b/deps/acelite/ace/FIFO_Send_Msg.h deleted file mode 100644 index 0e15c0e2e..000000000 --- a/deps/acelite/ace/FIFO_Send_Msg.h +++ /dev/null @@ -1,88 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file FIFO_Send_Msg.h - * - * @author Doug Schmidt - */ -//============================================================================= - - -#ifndef ACE_FIFO_SEND_MSG_H -#define ACE_FIFO_SEND_MSG_H -#include /**/ "ace/pre.h" - -#include "ace/FIFO_Send.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_STREAM_PIPES) -# include "ace/OS_NS_stropts.h" -#endif /* ACE_HAS_STREAM_PIPES */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward Decls -class ACE_Str_Buf; - -/** - * @class ACE_FIFO_Send_Msg - * - * @brief Sender side for the Record oriented C++ wrapper for UNIX - * FIFOs. - */ -class ACE_Export ACE_FIFO_Send_Msg : public ACE_FIFO_Send -{ -public: - /// Default constructor. - ACE_FIFO_Send_Msg (void); - - /// Open up a record-oriented named pipe for writing. - ACE_FIFO_Send_Msg (const ACE_TCHAR *rendezvous, - int flags = O_WRONLY, - mode_t perms = ACE_DEFAULT_FILE_PERMS, - LPSECURITY_ATTRIBUTES sa = 0); - - /// Open up a record-oriented named pipe for writing. - int open (const ACE_TCHAR *rendezvous, - int flags = O_WRONLY, - mode_t perms = ACE_DEFAULT_FILE_PERMS, - LPSECURITY_ATTRIBUTES sa = 0); - - /// Send @a buf of up to @a len bytes. - ssize_t send (const ACE_Str_Buf &msg); - - /// Send @a buf of exactly @a len bytes (block until done). - ssize_t send (const void *buf, size_t len); - -#if defined (ACE_HAS_STREAM_PIPES) - /// Send @a data and @a cntl message via Stream pipes. - ssize_t send (const ACE_Str_Buf *data, - const ACE_Str_Buf *cntl = 0, - int flags = 0); - - /// Send @a data and @a cntl message via Stream pipes in "band" mode. - ssize_t send (int band, - const ACE_Str_Buf *data, - const ACE_Str_Buf *cntl = 0, - int flags = MSG_BAND); -#endif /* ACE_HAS_STREAM_PIPES */ - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/FIFO_Send_Msg.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_FIFO_SEND_MSG_H */ diff --git a/deps/acelite/ace/FIFO_Send_Msg.inl b/deps/acelite/ace/FIFO_Send_Msg.inl deleted file mode 100644 index 74aaa1971..000000000 --- a/deps/acelite/ace/FIFO_Send_Msg.inl +++ /dev/null @@ -1,50 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_stropts.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE ssize_t -ACE_FIFO_Send_Msg::send (const void *buf, size_t len) -{ - ACE_TRACE ("ACE_FIFO_Send_Msg::send"); - ACE_Str_Buf send_msg ((char *) buf, static_cast (len)); - - return this->send (send_msg); -} - -#if defined (ACE_HAS_STREAM_PIPES) -ACE_INLINE ssize_t -ACE_FIFO_Send_Msg::send (const ACE_Str_Buf *data, - const ACE_Str_Buf *cntl, - int flags) -{ - ACE_TRACE ("ACE_FIFO_Send_Msg::send"); - if (ACE_OS::putmsg (this->get_handle (), - (strbuf *) cntl, - (strbuf *) data, - flags) == -1) - return-1; - else - return (cntl == 0 ? 0 : cntl->len) + (data == 0 ? 0 : data->len); -} - -ACE_INLINE ssize_t -ACE_FIFO_Send_Msg::send (int band, - const ACE_Str_Buf *data, - const ACE_Str_Buf *cntl, - int flags) -{ - ACE_TRACE ("ACE_FIFO_Send_Msg::send"); - - if (ACE_OS::putpmsg (this->get_handle (), - (strbuf *) cntl, - (strbuf *) data, - band, - flags) == -1) - return -1; - else - return (cntl == 0 ? 0 : cntl->len) + (data == 0 ? 0 : data->len); -} -#endif /* ACE_HAS_STREAM_PIPES */ - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FILE.cpp b/deps/acelite/ace/FILE.cpp deleted file mode 100644 index f7be0af71..000000000 --- a/deps/acelite/ace/FILE.cpp +++ /dev/null @@ -1,149 +0,0 @@ -/* Defines the member functions for the base class of the ACE_IO_SAP - ACE_FILE abstraction. */ - -#include "ace/FILE.h" - -#include "ace/OS_NS_unistd.h" -#include "ace/OS_NS_sys_stat.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/FILE.inl" -#endif /* __ACE_INLINE__ */ - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_FILE) - -void -ACE_FILE::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_FILE::dump"); - ACE_IO_SAP::dump (); -#endif /* ACE_HAS_DUMP */ -} - -// This is the do-nothing constructor. - -ACE_FILE::ACE_FILE (void) -{ - ACE_TRACE ("ACE_FILE::ACE_FILE"); -} - -// Close the file - -int -ACE_FILE::close (void) -{ - ACE_TRACE ("ACE_FILE::close"); - int result = 0; - - if (this->get_handle () != ACE_INVALID_HANDLE) - { - result = ACE_OS::close (this->get_handle ()); - this->set_handle (ACE_INVALID_HANDLE); - } - return result; -} - -int -ACE_FILE::get_info (ACE_FILE_Info *finfo) -{ - ACE_TRACE ("ACE_FILE::get_info"); - ACE_stat filestatus; - - int const result = ACE_OS::fstat (this->get_handle (), &filestatus); - - if (result == 0) - { - finfo->mode_ = filestatus.st_mode; - finfo->nlink_ = filestatus.st_nlink; - finfo->size_ = filestatus.st_size; - } - - return result; -} - -int -ACE_FILE::get_info (ACE_FILE_Info &finfo) -{ - ACE_TRACE ("ACE_FILE::get_info"); - - return this->get_info (&finfo); -} - -int -ACE_FILE::truncate (ACE_OFF_T length) -{ - ACE_TRACE ("ACE_FILE::truncate"); - return ACE_OS::ftruncate (this->get_handle (), length); -} - -ACE_OFF_T -ACE_FILE::seek (ACE_OFF_T offset, int startpos) -{ - return ACE_OS::lseek (this->get_handle (), offset, startpos); -} - -ACE_OFF_T -ACE_FILE::tell (void) -{ - ACE_TRACE ("ACE_FILE::tell"); - return ACE_OS::lseek (this->get_handle (), 0, SEEK_CUR); -} - -// Return the local endpoint address. - -int -ACE_FILE::get_local_addr (ACE_Addr &addr) const -{ - ACE_TRACE ("ACE_FILE::get_local_addr"); - - // Perform the downcast since had better be an - // . - ACE_FILE_Addr *file_addr = - dynamic_cast (&addr); - - if (file_addr == 0) - return -1; - else - { - *file_addr = this->addr_; - return 0; - } -} - -// Return the same result as . - -int -ACE_FILE::get_remote_addr (ACE_Addr &addr) const -{ - ACE_TRACE ("ACE_FILE::get_remote_addr"); - - return this->get_local_addr (addr); -} - -int -ACE_FILE::remove (void) -{ - ACE_TRACE ("ACE_FILE::remove"); - - this->close (); - return ACE_OS::unlink (this->addr_.get_path_name ()); -} - -int -ACE_FILE::unlink (void) -{ - ACE_TRACE ("ACE_FILE::unlink"); - - return ACE_OS::unlink (this->addr_.get_path_name ()); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FILE.h b/deps/acelite/ace/FILE.h deleted file mode 100644 index e128eda3a..000000000 --- a/deps/acelite/ace/FILE.h +++ /dev/null @@ -1,124 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file FILE.h - * - * @author Gerhard Lenzer - */ -//============================================================================= - -#ifndef ACE_FILE_H -#define ACE_FILE_H -#include /**/ "ace/pre.h" - -#include "ace/IO_SAP.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/FILE_Addr.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_FILE_Info - * - * @brief Abstracts basic OS FILE information. - */ -class ACE_Export ACE_FILE_Info -{ -public: - /// Mode of file - mode_t mode_; - - /// No of links - nlink_t nlink_; - - /// Size of file - ACE_OFF_T size_; -}; - -/** - * @class ACE_FILE - * - * @brief Defines the core methods of the ACE_FILE abstraction. - */ -class ACE_Export ACE_FILE : public ACE_IO_SAP -{ -public: - /// Close the ACE_FILE handle without removing the ACE_FILE from - /// the file system. - int close (void); - - /// Close and remove the ACE_FILE from the file system. - int remove (void); - - /// Remove the ACE_FILE from the file system without closing the - /// ACE_FILE handle. - int unlink (void); - - /// Get information on this ACE_FILE. - int get_info (ACE_FILE_Info *finfo); - - /// Get information on this ACE_FILE. - int get_info (ACE_FILE_Info &finfo); - - /// Set filesize to length byte. - int truncate (ACE_OFF_T length); - - /** - * Sets the file pointer as follows: - * o If @ whence is @c SEEK_SET, the pointer is set to @a offset - * bytes. - * - * o If @a whence> is @c SEEK_CUR, the pointer is set to its - * current location plus @a offset. - * - * o If @a whence is @c SEEK_END, the pointer is set to the size - * of the file plus offset. - */ - ACE_OFF_T seek (ACE_OFF_T offset, - int whence = SEEK_CUR); - - /// Return an offset for the file handle. - ACE_OFF_T tell (void); - - /** - * Disable signal @a signum - * This is here to prevent Win32 from - * disabling SPIPE using socket calls - */ - int disable (int signum) const ; - - /// Return the local endpoint address in the referenced ACE_Addr. - /// Returns 0 if successful, else -1. - int get_local_addr (ACE_Addr &) const; - - /// Return the same thing as get_local_addr(). - int get_remote_addr (ACE_Addr &) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Ensure that this class is only created by the - /// ACE_FILE_Connector. - ACE_FILE (void); - - /// File we are "connected" with... - ACE_FILE_Addr addr_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/FILE.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_FILE_H */ diff --git a/deps/acelite/ace/FILE.inl b/deps/acelite/ace/FILE.inl deleted file mode 100644 index 69c3e0cd2..000000000 --- a/deps/acelite/ace/FILE.inl +++ /dev/null @@ -1,15 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE int -ACE_FILE::disable (int signum) const -{ -#if defined (ACE_WIN32) - ACE_UNUSED_ARG (signum) ; - return 0 ; -#else /* ACE_WIN32 */ - return ACE_IO_SAP::disable (signum) ; -#endif /* ACE_WIN32 */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FILE_Addr.cpp b/deps/acelite/ace/FILE_Addr.cpp deleted file mode 100644 index 9d043f5fc..000000000 --- a/deps/acelite/ace/FILE_Addr.cpp +++ /dev/null @@ -1,129 +0,0 @@ -#include "ace/FILE_Addr.h" -#include "ace/Lib_Find.h" -#include "ace/Log_Category.h" -#include "ace/OS_NS_stdlib.h" -#include "ace/OS_NS_string.h" -#include "ace/os_include/sys/os_socket.h" - -#if !defined (__ACE_INLINE__) -#include "ace/FILE_Addr.inl" -#endif /* __ACE_INLINE__ */ - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_FILE_Addr) - -ACE_FILE_Addr::ACE_FILE_Addr (void) - : ACE_Addr (AF_FILE, sizeof this->filename_ / sizeof (ACE_TCHAR)) -{ - this->filename_[0] = '\0'; -} - -int -ACE_FILE_Addr::set (const ACE_FILE_Addr &sa) -{ - if (sa.get_type () == AF_ANY) - { -#if defined (ACE_DISABLE_MKTEMP) - // Built without mktemp support; punt back to caller. - errno = ENOTSUP; - return -1; -#else - -# if defined (ACE_DEFAULT_TEMP_FILE) - // Create a temporary file. - ACE_OS::strcpy (this->filename_, - ACE_DEFAULT_TEMP_FILE); -# else /* ACE_DEFAULT_TEMP_FILE */ - if (ACE::get_temp_dir (this->filename_, MAXPATHLEN - 15) == -1) - // -15 for ace-file-XXXXXX - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("Temporary path too long, ") - ACE_TEXT ("defaulting to current directory\n"))); - this->filename_[0] = 0; - } - - // Add the filename to the end - ACE_OS::strcat (this->filename_, ACE_TEXT ("ace-fileXXXXXX")); - -# endif /* ACE_DEFAULT_TEMP_FILE */ - - if (ACE_OS::mktemp (this->filename_) == 0) - return -1; - this->base_set (AF_FILE, - static_cast (ACE_OS::strlen (this->filename_) + 1)); -#endif /* ACE_DISABLE_MKTEMP */ - } - else - { - (void)ACE_OS::strsncpy (this->filename_, sa.filename_, sa.get_size ()); - - this->base_set (sa.get_type (), sa.get_size ()); - } - return 0; -} - -// Copy constructor. - -ACE_FILE_Addr::ACE_FILE_Addr (const ACE_FILE_Addr &sa) - : ACE_Addr (AF_FILE, sizeof this->filename_) -{ - this->set (sa); -} - -int -ACE_FILE_Addr::set (const ACE_TCHAR *filename) -{ - this->ACE_Addr::base_set (AF_FILE, - static_cast (ACE_OS::strlen (filename) + 1)); - (void) ACE_OS::strsncpy (this->filename_, - filename, - sizeof this->filename_ / sizeof (ACE_TCHAR)); - return 0; -} - -ACE_FILE_Addr & -ACE_FILE_Addr::operator= (const ACE_FILE_Addr &sa) -{ - if (this != &sa) - this->set (sa); - return *this; -} - -// Create a ACE_Addr from a ACE_FILE pathname. - -ACE_FILE_Addr::ACE_FILE_Addr (const ACE_TCHAR *filename) -{ - this->set (filename); -} - -int -ACE_FILE_Addr::addr_to_string (ACE_TCHAR *s, size_t len) const -{ - ACE_OS::strsncpy (s, this->filename_, len); - return 0; -} - -// Return the address. - -void * -ACE_FILE_Addr::get_addr (void) const -{ - return (void *)&this->filename_; -} - -void -ACE_FILE_Addr::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_FILE_Addr::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("filename_ = %s"), this->filename_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FILE_Addr.h b/deps/acelite/ace/FILE_Addr.h deleted file mode 100644 index 79c14d4cb..000000000 --- a/deps/acelite/ace/FILE_Addr.h +++ /dev/null @@ -1,86 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file FILE_Addr.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_FILE_ADDR_H -#define ACE_FILE_ADDR_H -#include /**/ "ace/pre.h" - -#include "ace/Addr.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Flag_Manip.h" -#include "ace/os_include/os_dirent.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_FILE_Addr - * - * @brief Defines the FILE address family address format. - */ -class ACE_Export ACE_FILE_Addr : public ACE_Addr -{ -public: - /// Default constructor. - ACE_FILE_Addr (void); - - /// Copy constructor. - ACE_FILE_Addr (const ACE_FILE_Addr &sa); - - /// Acts like a copy constructor. If @a sa == ACE_Addr::sap_any then - /// create a temporary filename using ACE_OS::mktemp. - int set (const ACE_FILE_Addr &sa); - - /// Create a ACE_FILE_Addr from a pathname. - explicit ACE_FILE_Addr (const ACE_TCHAR *filename); - - /// Create a ACE_FILE_Addr from a pathname. - int set (const ACE_TCHAR *filename); - - /// Assignment operator. - ACE_FILE_Addr &operator= (const ACE_FILE_Addr &); - - /// Return a pointer to the address. - virtual void *get_addr (void) const; - - /// Transform the current address into string format. - virtual int addr_to_string (ACE_TCHAR *addr, size_t) const; - - /// Compare two addresses for equality. - bool operator == (const ACE_FILE_Addr &SAP) const; - - /// Compare two addresses for inequality. - bool operator != (const ACE_FILE_Addr &SAP) const; - - /// Return the path name used for the rendezvous point. - const ACE_TCHAR *get_path_name (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Name of the file. - ACE_TCHAR filename_[MAXPATHLEN + 1]; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/FILE_Addr.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_FILE_ADDR_H */ diff --git a/deps/acelite/ace/FILE_Addr.inl b/deps/acelite/ace/FILE_Addr.inl deleted file mode 100644 index c873ba8b0..000000000 --- a/deps/acelite/ace/FILE_Addr.inl +++ /dev/null @@ -1,31 +0,0 @@ -// -*- C++ -*- - -#include "ace/SString.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Compare two addresses for equality. - -ACE_INLINE bool -ACE_FILE_Addr::operator == (const ACE_FILE_Addr &sap) const -{ - return ACE_OS::strcmp (this->filename_, sap.filename_) == 0; -} - -// Compare two addresses for inequality. - -ACE_INLINE bool -ACE_FILE_Addr::operator != (const ACE_FILE_Addr &sap) const -{ - return !((*this) == sap); // This is lazy, of course... ;-) -} - -// Return the path name used for the rendezvous point. - -ACE_INLINE const ACE_TCHAR * -ACE_FILE_Addr::get_path_name (void) const -{ - return this->filename_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FILE_Connector.cpp b/deps/acelite/ace/FILE_Connector.cpp deleted file mode 100644 index 5ff46dec5..000000000 --- a/deps/acelite/ace/FILE_Connector.cpp +++ /dev/null @@ -1,85 +0,0 @@ -#include "ace/FILE_Connector.h" -#include "ace/Handle_Ops.h" -#include "ace/OS_NS_stdlib.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/FILE_Connector.inl" -#endif /* __ACE_INLINE__ */ - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_FILE_Connector) - -void -ACE_FILE_Connector::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_FILE_Connector::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n"))); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_FILE_Connector::ACE_FILE_Connector (void) -{ - ACE_TRACE ("ACE_FILE_Connector::ACE_FILE_Connector"); -} - -int -ACE_FILE_Connector::connect (ACE_FILE_IO &new_io, - const ACE_FILE_Addr &remote_sap, - ACE_Time_Value *timeout, - const ACE_Addr &, - int, - int flags, - int perms) -{ - ACE_TRACE ("ACE_FILE_Connector::connect"); - ACE_ASSERT (new_io.get_handle () == ACE_INVALID_HANDLE); - - ACE_HANDLE handle = ACE_INVALID_HANDLE; - - // Check to see if caller has requested that we create the filename. - if (reinterpret_cast ( - const_cast (remote_sap)) == ACE_Addr::sap_any) - { - // Create a new temporary file. - // Use ACE_OS::mkstemp() if it is available since it avoids a - // race condition, and subsequently a security hole due to that - // race condition (specifically, a denial-of-service attack). - // - // However, using mkstemp() prevents us from doing a timed open - // since it opens the file for us. Better to avoid the race - // condition. - char filename[] = "ace-file-XXXXXX"; - - handle = ACE_OS::mkstemp (filename); // mkstemp() replaces "XXXXXX" - - if (handle == ACE_INVALID_HANDLE - || new_io.addr_.set (ACE_TEXT_CHAR_TO_TCHAR (filename)) != 0) - return -1; - - new_io.set_handle (handle); - - return 0; - } - else - new_io.addr_ = remote_sap; // class copy. - - handle = ACE::handle_timed_open (timeout, - new_io.addr_.get_path_name (), - flags, - perms); - - new_io.set_handle (handle); - return handle == ACE_INVALID_HANDLE ? -1 : 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FILE_Connector.h b/deps/acelite/ace/FILE_Connector.h deleted file mode 100644 index 76e781560..000000000 --- a/deps/acelite/ace/FILE_Connector.h +++ /dev/null @@ -1,110 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file FILE_Connector.h - * - * @author Doug Schmidt - */ -//============================================================================= - -#ifndef ACE_FILE_CONNECTOR_H -#define ACE_FILE_CONNECTOR_H -#include /**/ "ace/pre.h" - -#include "ace/FILE_IO.h" -#include "ace/Log_Category.h" -#include "ace/os_include/os_fcntl.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_FILE_Connector - * - * @brief Defines an active connection factory for the ACE_FILE wrappers. - * - * Note that the O_APPEND flag is only partly supported on Win32. If - * you specify O_APPEND, then the file pointer will be positioned at - * the end of the file initially during open, but it is not - * re-positioned at the end prior to each write, as specified by - * POSIX. This is generally good enough for typical situations, but - * it is ``not quite right'' in its semantics. - */ -class ACE_Export ACE_FILE_Connector -{ -public: - /// Default constructor. - ACE_FILE_Connector (void); - - /** - * Actively ``connect'' and produce a @a new_io ACE_FILE_IO object - * if things go well. The @a remote_sap is the file that we are - * trying to create/open. If it's the default value of - * ACE_Addr::sap_any then the user is letting the OS create the - * filename (via ). The @a timeout is the amount of - * time to wait to create/open the file. If it's 0 then we block - * indefinitely. If *timeout == {0, 0} then the file is created - * using non-blocking mode. If *timeout > {0, 0} then this is the - * maximum amount of time to wait before timing out. The - * @a local_sap and @a reuse_addr parameters are ignored. The @a flags - * and @a perms arguments are passed down to the - * method. - */ - ACE_FILE_Connector (ACE_FILE_IO &new_io, - const ACE_FILE_Addr &remote_sap, - ACE_Time_Value *timeout = 0, - const ACE_Addr &local_sap = ACE_Addr::sap_any, - int reuse_addr = 0, - int flags = O_RDWR | O_CREAT, - int perms = ACE_DEFAULT_FILE_PERMS); - - /** - * Actively ``connect'' and produce a @a new_io object - * if things go well. The @a remote_sap is the file that we are - * trying to create/open. If it's the default value of - * ACE_Addr::sap_any then the user is letting the OS create the - * filename (via ). The @a timeout is the amount of - * time to wait to create/open the file. If it's 0 then we block - * indefinitely. If *timeout == {0, 0} then the file is created - * using non-blocking mode. In this case, if the create/open can't - * be done immediately the value of -1 is returned with . If *timeout > {0, 0} then this is the maximum amount of - * time to wait before timing out. If the time expires before the - * connection is made @c errno == ETIME. The @a local_sap and - * @a reuse_addr parameters are ignored. The @a flags and @a perms - * arguments are passed down to the method. - */ - int connect (ACE_FILE_IO &new_io, - const ACE_FILE_Addr &remote_sap, - ACE_Time_Value *timeout = 0, - const ACE_Addr &local_sap = ACE_Addr::sap_any, - int reuse_addr = 0, - int flags = O_RDWR | O_CREAT, - int perms = ACE_DEFAULT_FILE_PERMS); - - /// Resets any event associations on this handle - bool reset_new_handle (ACE_HANDLE handle); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - // = Meta-type "trait" information. - typedef ACE_FILE_Addr PEER_ADDR; - typedef ACE_FILE_IO PEER_STREAM; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/FILE_Connector.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_FILE_CONNECTOR_H */ diff --git a/deps/acelite/ace/FILE_Connector.inl b/deps/acelite/ace/FILE_Connector.inl deleted file mode 100644 index a12a6573b..000000000 --- a/deps/acelite/ace/FILE_Connector.inl +++ /dev/null @@ -1,32 +0,0 @@ -// -*- C++ -*- -// Creates a Local ACE_FILE. - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_FILE_Connector::ACE_FILE_Connector (ACE_FILE_IO &new_io, - const ACE_FILE_Addr &remote_sap, - ACE_Time_Value *timeout, - const ACE_Addr &local_sap, - int reuse_addr, - int flags, - int perms) -{ - ACE_TRACE ("ACE_FILE_Connector::ACE_FILE_Connector"); - if (this->connect (new_io, remote_sap, timeout, local_sap, - reuse_addr, flags, perms) == ACE_IO_SAP::INVALID_HANDLE - && timeout != 0 && !(errno == EWOULDBLOCK || errno == ETIME)) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("address %s, %p\n"), - remote_sap.get_path_name (), - ACE_TEXT ("ACE_FILE_IO"))); -} - -ACE_INLINE bool -ACE_FILE_Connector::reset_new_handle (ACE_HANDLE) -{ - // Nothing to do here since the handle is not a socket - return false; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FILE_IO.cpp b/deps/acelite/ace/FILE_IO.cpp deleted file mode 100644 index 1a999c83e..000000000 --- a/deps/acelite/ace/FILE_IO.cpp +++ /dev/null @@ -1,185 +0,0 @@ -#include "ace/FILE_IO.h" - -#include "ace/Log_Category.h" -#include "ace/OS_NS_sys_stat.h" -#include "ace/OS_Memory.h" -#include "ace/Truncate.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/FILE_IO.inl" -#endif /* __ACE_INLINE__ */ - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_FILE_IO) - -void -ACE_FILE_IO::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_FILE_IO::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->addr_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -// Simple-minded do nothing constructor. - -ACE_FILE_IO::ACE_FILE_IO (void) -{ - ACE_TRACE ("ACE_FILE_IO::ACE_FILE_IO"); -} - -// Send N char *ptrs and int lengths. Note that the char *'s precede -// the ints (basically, an varargs version of writev). The count N is -// the *total* number of trailing arguments, *not* a couple of the -// number of tuple pairs! - -ssize_t -ACE_FILE_IO::send (size_t n, ...) const -{ - ACE_TRACE ("ACE_FILE_IO::send"); -#ifdef ACE_LACKS_VA_FUNCTIONS - ACE_UNUSED_ARG (n); - ACE_NOTSUP_RETURN (-1); -#else - va_list argp; - int total_tuples = ACE_Utils::truncate_cast (n / 2); - iovec *iovp = 0; -#if defined (ACE_HAS_ALLOCA) - iovp = (iovec *) alloca (total_tuples * sizeof (iovec)); -#else -# ifdef ACE_HAS_ALLOC_HOOKS - ACE_ALLOCATOR_RETURN (iovp, (iovec *) - ACE_Allocator::instance ()->malloc (total_tuples * - sizeof (iovec)), - -1); -# else - ACE_NEW_RETURN (iovp, - iovec[total_tuples], - -1); -# endif /* ACE_HAS_ALLOC_HOOKS */ -#endif /* !defined (ACE_HAS_ALLOCA) */ - - va_start (argp, n); - - for (int i = 0; i < total_tuples; i++) - { - iovp[i].iov_base = va_arg (argp, char *); - iovp[i].iov_len = va_arg (argp, int); - } - - ssize_t result = ACE_OS::writev (this->get_handle (), - iovp, - total_tuples); -#if !defined (ACE_HAS_ALLOCA) -# ifdef ACE_HAS_ALLOC_HOOKS - ACE_Allocator::instance ()->free (iovp); -# else - delete [] iovp; -# endif /* ACE_HAS_ALLOC_HOOKS */ -#endif /* !defined (ACE_HAS_ALLOCA) */ - va_end (argp); - return result; -#endif // ACE_LACKS_VA_FUNCTIONS -} - -// This is basically an interface to ACE_OS::readv, that doesn't use -// the struct iovec explicitly. The ... can be passed as an arbitrary -// number of (char *ptr, int len) tuples. However, the count N is the -// *total* number of trailing arguments, *not* a couple of the number -// of tuple pairs! - -ssize_t -ACE_FILE_IO::recv (size_t n, ...) const -{ - ACE_TRACE ("ACE_FILE_IO::recv"); -#ifdef ACE_LACKS_VA_FUNCTIONS - ACE_UNUSED_ARG (n); - ACE_NOTSUP_RETURN (-1); -#else - va_list argp; - int total_tuples = ACE_Utils::truncate_cast (n / 2); - iovec *iovp = 0; -#if defined (ACE_HAS_ALLOCA) - iovp = (iovec *) alloca (total_tuples * sizeof (iovec)); -#else -# ifdef ACE_HAS_ALLOC_HOOKS - ACE_ALLOCATOR_RETURN (iovp, (iovec *) - ACE_Allocator::instance ()->malloc (total_tuples * - sizeof (iovec)), - -1); -# else - ACE_NEW_RETURN (iovp, - iovec[total_tuples], - -1); -# endif /* ACE_HAS_ALLOC_HOOKS */ -#endif /* !defined (ACE_HAS_ALLOCA) */ - - va_start (argp, n); - - for (int i = 0; i < total_tuples; i++) - { - iovp[i].iov_base = va_arg (argp, char *); - iovp[i].iov_len = va_arg (argp, int); - } - - ssize_t const result = ACE_OS::readv (this->get_handle (), - iovp, - total_tuples); -#if !defined (ACE_HAS_ALLOCA) -# ifdef ACE_HAS_ALLOC_HOOKS - ACE_Allocator::instance ()->free (iovp); -# else - delete [] iovp; -# endif /* ACE_HAS_ALLOC_HOOKS */ -#endif /* !defined (ACE_HAS_ALLOCA) */ - va_end (argp); - return result; -#endif // ACE_LACKS_VA_FUNCTIONS -} - -// Allows a client to read from a file without having to provide a -// buffer to read. This method determines how much data is in the -// file, allocates a buffer of this size, reads in the data, and -// returns the number of bytes read. - -ssize_t -ACE_FILE_IO::recvv (iovec *io_vec) -{ - ACE_TRACE ("ACE_FILE_IO::recvv"); - - io_vec->iov_base = 0; - ACE_OFF_T const length = ACE_OS::filesize (this->get_handle ()); - - if (length > 0) - { - // Restrict to max size we can record in iov_len. - size_t len = ACE_Utils::truncate_cast (length); -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (io_vec->iov_base, - static_cast(ACE_Allocator::instance()->malloc(sizeof(char) * len)), - -1); -#else - ACE_NEW_RETURN (io_vec->iov_base, - char[len], - -1); -#endif /* ACE_HAS_ALLOC_HOOKS */ - io_vec->iov_len = static_cast (this->recv_n (io_vec->iov_base, - len)); - return io_vec->iov_len; - } - else - { - return ACE_Utils::truncate_cast (length); - } -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/FILE_IO.h b/deps/acelite/ace/FILE_IO.h deleted file mode 100644 index bc0bfc712..000000000 --- a/deps/acelite/ace/FILE_IO.h +++ /dev/null @@ -1,167 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file FILE_IO.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_FILE_IO_H -#define ACE_FILE_IO_H -#include /**/ "ace/pre.h" - -#include "ace/FILE.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/FILE_Addr.h" - -// Used in the FILE_IO.h file... -#include "ace/os_include/os_stdio.h" -#include "ace/os_include/sys/os_uio.h" - -#if defined (ACE_HAS_STREAM_PIPES) -# include "ace/OS_NS_stropts.h" -#endif /* ACE_HAS_STREAM_PIPES */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward decl. -class ACE_Message_Block; -class ACE_Time_Value; - -/** - * @class ACE_FILE_IO - * - * @brief Read/Write operations on Files - */ -class ACE_Export ACE_FILE_IO : public ACE_FILE -{ -public: - friend class ACE_FILE_Connector; - - /// Default constructor. - ACE_FILE_IO (void); - - /// send upto @a n bytes in @a buf. - ssize_t send (const void *buf, size_t n) const; - - /// Recv upto @a n bytes in @a buf. - ssize_t recv (void *buf, size_t n) const; - - /// Send n bytes, keep trying until n are sent. - ssize_t send_n (const void *buf, size_t n) const; - - /// Send all the @a message_blocks chained through their next and - /// cont pointers. This call uses the underlying OS gather-write - /// operation to reduce the domain-crossing penalty. - ssize_t send_n (const ACE_Message_Block *message_block, - const ACE_Time_Value *timeout = 0, - size_t *bytes_transferred = 0); - - /// Recv n bytes, keep trying until n are received. - ssize_t recv_n (void *buf, size_t n) const; - -#if defined (ACE_HAS_STREAM_PIPES) - /// Send bytes via STREAM pipes. - ssize_t send (const ACE_Str_Buf *cntl, - const ACE_Str_Buf *data, - int flags = 0) const; - - /// Recv bytes via STREAM pipes. - ssize_t recv (ACE_Str_Buf *cntl, - ACE_Str_Buf *data, - int *flags) const; - - /// Send bytes via STREAM pipes using "band" mode. - ssize_t send (const ACE_Str_Buf *cntl, - const ACE_Str_Buf *data, - int band, - int flags) const; - - /// Recv bytes via STREAM pipes using "band" mode. - ssize_t recv (ACE_Str_Buf *cntl, - ACE_Str_Buf *data, - int *band, - int *flags) const; - -#endif /* ACE_HAS_STREAM_PIPES */ - - /// Send iovecs via <::writev>. - ssize_t send (const iovec iov[], int n) const; - - /// Recv iovecs via <::readv>. - ssize_t recv (iovec iov[], int n) const; - - /** - * Send N char *ptrs and int lengths. Note that the char *'s - * precede the ints (basically, an varargs version of writev). The - * count N is the *total* number of trailing arguments, *not* a - * couple of the number of tuple pairs! - */ - ssize_t send (size_t n, ...) const; - - /** - * This is an interface to ::readv, that doesn't use the struct - * iovec explicitly. The ... can be passed as an arbitrary number - * of (char *ptr, int len) tuples. However, the count N is the - * *total* number of trailing arguments, *not* a couple of the - * number of tuple pairs! - */ - ssize_t recv (size_t n, ...) const; - - /// Send @a n bytes via Win32 WriteFile using overlapped I/O. - ssize_t send (const void *buf, - size_t n, - ACE_OVERLAPPED *overlapped) const; - - /// Recv @a n bytes via Win32 ReadFile using overlapped I/O. - ssize_t recv (void *buf, - size_t n, - ACE_OVERLAPPED *overlapped) const; - - /// Send an @c iovec of size @a n to the file. - ssize_t sendv (const iovec iov[], - int n) const; - - /** - * Allows a client to read from a file without having to provide a - * buffer to read. This method determines how much data is in the - * file, allocates a buffer of this size, reads in the data, and - * returns the number of bytes read. The caller is responsible for - * deleting the member in the field of using - * delete [] io_vec->iov_base. - */ - ssize_t recvv (iovec *io_vec); - - /// Send an of size @a n to the file. Will block until all - /// bytes are sent or an error occurs. - ssize_t sendv_n (const iovec iov[], - int n) const; - - /// Receive an of size @a n to the file. - ssize_t recvv_n (iovec iov[], - int n) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - // = Meta-type info - typedef ACE_FILE_Addr PEER_ADDR; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/FILE_IO.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_FILE_IO_H */ diff --git a/deps/acelite/ace/FILE_IO.inl b/deps/acelite/ace/FILE_IO.inl deleted file mode 100644 index 57c300490..000000000 --- a/deps/acelite/ace/FILE_IO.inl +++ /dev/null @@ -1,149 +0,0 @@ -// -*- C++ -*- -#include "ace/ACE.h" -#include "ace/OS_NS_sys_uio.h" -#include "ace/OS_NS_unistd.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE ssize_t -ACE_FILE_IO::sendv_n (const iovec iov[], int n) const -{ - ACE_TRACE ("ACE_FILE_IO::sendv_n"); - return ACE::writev_n (this->get_handle (), - iov, - n); -} - -ACE_INLINE ssize_t -ACE_FILE_IO::send_n (const ACE_Message_Block *message_block, - const ACE_Time_Value *timeout, - size_t *bytes_transferred) -{ - ACE_TRACE ("ACE_FILE_IO::send_n"); - ACE_UNUSED_ARG (timeout); - return ACE::write_n (this->get_handle (), - message_block, - bytes_transferred); -} - -// Recv an n byte message from the file. - -ACE_INLINE ssize_t -ACE_FILE_IO::recvv_n (iovec iov[], int n) const -{ - ACE_TRACE ("ACE_FILE_IO::recvv_n"); - // @@ Carlos, can you please update this to call the - // new ACE::recvv_n() method that you write? - return ACE_OS::readv (this->get_handle (), - iov, - n); -} - -// Send an of size to the file. - -ACE_INLINE ssize_t -ACE_FILE_IO::sendv (const iovec iov[], int n) const -{ - ACE_TRACE ("ACE_FILE_IO::sendv"); - return ACE_OS::writev (this->get_handle (), iov, n); -} - -// Send exactly N bytes from BUF to this file. Keeping trying until -// this many bytes are sent. - -ACE_INLINE ssize_t -ACE_FILE_IO::send_n (const void *buf, size_t n) const -{ - ACE_TRACE ("ACE_FILE_IO::send_n"); - return ACE::write_n (this->get_handle (), buf, n); -} - -// Receive exactly N bytes from this file into BUF. Keep trying until -// this many bytes are received. - -ACE_INLINE ssize_t -ACE_FILE_IO::recv_n (void *buf, size_t n) const -{ - ACE_TRACE ("ACE_FILE_IO::recv_n"); - return ACE::read_n (this->get_handle (), buf, n); -} - -ACE_INLINE ssize_t -ACE_FILE_IO::send (const void *buf, size_t n) const -{ - ACE_TRACE ("ACE_FILE_IO::send"); - return ACE_OS::write (this->get_handle (), buf, n); -} - -ACE_INLINE ssize_t -ACE_FILE_IO::recv (void *buf, size_t n) const -{ - ACE_TRACE ("ACE_FILE_IO::recv"); - return ACE_OS::read (this->get_handle (), buf, n); -} - -ACE_INLINE ssize_t -ACE_FILE_IO::send (const iovec iov[], int n) const -{ - ACE_TRACE ("ACE_FILE_IO::send"); - return ACE_OS::writev (this->get_handle (), iov, n); -} - -ACE_INLINE ssize_t -ACE_FILE_IO::recv (iovec iov[], int n) const -{ - ACE_TRACE ("ACE_FILE_IO::recv"); - return ACE_OS::readv (this->get_handle (), iov, n); -} - -#if defined (ACE_HAS_STREAM_PIPES) -ACE_INLINE ssize_t -ACE_FILE_IO::recv (ACE_Str_Buf *cntl, ACE_Str_Buf *data, int *band, int *flags) const -{ - ACE_TRACE ("ACE_FILE_IO::recv"); - return ACE_OS::getpmsg (this->get_handle (), (strbuf *) cntl, (strbuf *) data, band, flags); -} - -ACE_INLINE ssize_t -ACE_FILE_IO::send (const ACE_Str_Buf *cntl, const ACE_Str_Buf *data, int band, int flags) const -{ - ACE_TRACE ("ACE_FILE_IO::send"); - return ACE_OS::putpmsg (this->get_handle (), (strbuf *) cntl, (strbuf *) data, band, flags); -} - -ACE_INLINE ssize_t -ACE_FILE_IO::recv (ACE_Str_Buf *cntl, ACE_Str_Buf *data, int *flags) const -{ - ACE_TRACE ("ACE_FILE_IO::recv"); - return ACE_OS::getmsg (this->get_handle (), (strbuf *) cntl, (strbuf *) data, flags); -} - -ACE_INLINE ssize_t -ACE_FILE_IO::send (const ACE_Str_Buf *cntl, const ACE_Str_Buf *data, int flags) const -{ - ACE_TRACE ("ACE_FILE_IO::send"); - return ACE_OS::putmsg (this->get_handle (), (strbuf *) cntl, (strbuf *) data, flags); -} - -ACE_INLINE ssize_t -ACE_FILE_IO::send (const void *buf, size_t n, - ACE_OVERLAPPED *overlapped) const -{ - ACE_TRACE ("ACE_FILE_IO::send"); - return ACE_OS::write (this->get_handle (), - buf, n, - overlapped); -} - -ACE_INLINE ssize_t -ACE_FILE_IO::recv (void *buf, size_t n, - ACE_OVERLAPPED *overlapped) const -{ - ACE_TRACE ("ACE_FILE_IO::recv"); - return ACE_OS::read (this->get_handle (), buf, n, - overlapped); -} - -#endif /* ACE_HAS_STREAM_PIPES */ - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/File_Lock.cpp b/deps/acelite/ace/File_Lock.cpp deleted file mode 100644 index f5e421acb..000000000 --- a/deps/acelite/ace/File_Lock.cpp +++ /dev/null @@ -1,73 +0,0 @@ -#include "ace/File_Lock.h" -#include "ace/Log_Category.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/File_Lock.inl" -#endif /* __ACE_INLINE__ */ - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_File_Lock) - -void -ACE_File_Lock::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_File_Lock::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->lock_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_File_Lock::ACE_File_Lock (ACE_HANDLE h, - bool unlink_in_destructor) - : removed_ (false), - unlink_in_destructor_ (unlink_in_destructor) -{ -// ACE_TRACE ("ACE_File_Lock::ACE_File_Lock"); - if (ACE_OS::flock_init (&this->lock_) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_File_Lock::ACE_File_Lock"))); - this->set_handle (h); -} - -ACE_File_Lock::ACE_File_Lock (const ACE_TCHAR *name, - int flags, - mode_t perms, - bool unlink_in_destructor) - : unlink_in_destructor_ (unlink_in_destructor) -{ -// ACE_TRACE ("ACE_File_Lock::ACE_File_Lock"); - - if (this->open (name, flags, perms) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p %s\n"), - ACE_TEXT ("ACE_File_Lock::ACE_File_Lock"), - name)); -} - -int -ACE_File_Lock::open (const ACE_TCHAR *name, - int flags, - mode_t perms) -{ -// ACE_TRACE ("ACE_File_Lock::open"); - this->removed_ = false; - return ACE_OS::flock_init (&this->lock_, flags, name, perms); -} - -ACE_File_Lock::~ACE_File_Lock (void) -{ -// ACE_TRACE ("ACE_File_Lock::~ACE_File_Lock"); - this->remove (this->unlink_in_destructor_); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/File_Lock.h b/deps/acelite/ace/File_Lock.h deleted file mode 100644 index d71e42c00..000000000 --- a/deps/acelite/ace/File_Lock.h +++ /dev/null @@ -1,168 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file File_Lock.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_FILE_LOCK_H -#define ACE_FILE_LOCK_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/OS_NS_stdio.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_File_Lock - * - * @brief A wrapper around the UNIX file locking mechanism. - * - * Allows us to "adapt" the UNIX file locking mechanisms to work - * with all of our Guard stuff... - */ -class ACE_Export ACE_File_Lock -{ -public: - /** - * Set the of the File_Lock to @a handle. Note that this - * constructor assumes ownership of the @a handle and will close it - * down in . If you want the @a handle to stay open when - * is called make sure to call on the @a handle. - * If you don't want the file unlinked in the destructor pass a - * zero value for . - */ - ACE_File_Lock (ACE_HANDLE handle = ACE_INVALID_HANDLE, - bool unlink_in_destructor = true); - - /// Open the @a filename with @a flags and @a mode and set the result - /// to . If you don't want the file unlinked in the - /// destructor pass a false value for @a unlink_in_destructor. - ACE_File_Lock (const ACE_TCHAR *filename, - int flags, - mode_t mode = 0, - bool unlink_in_destructor = true); - - /// Open the @a filename with @a flags and @a mode and set the result to - /// . - int open (const ACE_TCHAR *filename, - int flags, - mode_t mode = 0); - - /// Remove a File lock by releasing it and closing down the . - ~ACE_File_Lock (void); - - /// Remove a File lock by releasing it and closing down the - /// . If @a unlink_file is true then we unlink the file. - int remove (bool unlink_file = true); - - /** - * Note, for interface uniformity with other synchronization - * wrappers we include the acquire() method. This is implemented as - * a write-lock to be on the safe-side... - */ - int acquire (short whence = 0, ACE_OFF_T start = 0, ACE_OFF_T len = 1); - - /** - * Note, for interface uniformity with other synchronization - * wrappers we include the method. This is implemented - * as a write-lock to be on the safe-side... Returns -1 on failure. - * If we "failed" because someone else already had the lock, @c errno - * is set to @c EBUSY. - */ - int tryacquire (short whence = 0, ACE_OFF_T start = 0, ACE_OFF_T len = 1); - - /// Unlock a readers/writer lock. - int release (short whence = 0, ACE_OFF_T start = 0, ACE_OFF_T len = 1); - - /// Acquire a write lock, but block if any readers or a - /// writer hold the lock. - int acquire_write (short whence = 0, ACE_OFF_T start = 0, ACE_OFF_T len = 1); - - /** - * Conditionally acquire a write lock (i.e., won't block). Returns - * -1 on failure. If we "failed" because someone else already had - * the lock, @c errno is set to @c EBUSY. - */ - int tryacquire_write (short whence = 0, ACE_OFF_T start = 0, ACE_OFF_T len = 1); - - /** - * Conditionally upgrade to a write lock (i.e., won't block). Returns - * -1 on failure. If we "failed" because someone else already had - * the lock, @c errno is set to @c EBUSY. - */ - int tryacquire_write_upgrade (short whence = 0, - ACE_OFF_T start = 0, - ACE_OFF_T len = 1); - - /** - * Acquire a read lock, but block if a writer hold the lock. - * Returns -1 on failure. If we "failed" because someone else - * already had the lock, @c errno is set to @c EBUSY. - */ - int acquire_read (short whence = 0, ACE_OFF_T start = 0, ACE_OFF_T len = 1); - - /** - * Conditionally acquire a read lock (i.e., won't block). Returns - * -1 on failure. If we "failed" because someone else already had - * the lock, @c errno is set to @c EBUSY. - */ - int tryacquire_read (short whence = 0, ACE_OFF_T start = 0, ACE_OFF_T len = 1); - - /// Get underlying ACE_HANDLE for the file. - ACE_HANDLE get_handle (void) const; - - /** - * Set underlying ACE_HANDLE. Note that this method assumes - * ownership of the @a handle and will close it down in . If - * you want the @a handle to stay open when is called make - * sure to call on the @a handle before closing it. You are - * responsible for the closing the existing @a handle before - * overwriting it. - */ - void set_handle (ACE_HANDLE); - - /// Dump state of the object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Locking structure for OS record locks. - ACE_OS::ace_flock_t lock_; - - /// Keeps track of whether has been called yet to avoid - /// multiple calls, e.g., explicitly and implicitly in the - /// destructor. This flag isn't protected by a lock, so make sure - /// that you don't have multiple threads simultaneously calling - /// on the same object, which is a bad idea anyway... - bool removed_; - - /// Keeps track of whether to unlink the underlying file in the - /// destructor. - bool const unlink_in_destructor_; - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_File_Lock &); - ACE_File_Lock (const ACE_File_Lock &); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/File_Lock.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_FILE_LOCK_H */ diff --git a/deps/acelite/ace/File_Lock.inl b/deps/acelite/ace/File_Lock.inl deleted file mode 100644 index fb9ae6e0c..000000000 --- a/deps/acelite/ace/File_Lock.inl +++ /dev/null @@ -1,93 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE int -ACE_File_Lock::acquire_read (short whence, ACE_OFF_T start, ACE_OFF_T len) -{ -// ACE_TRACE ("ACE_File_Lock::acquire_read"); - return ACE_OS::flock_rdlock (&this->lock_, whence, start, len); -} - -ACE_INLINE int -ACE_File_Lock::tryacquire_read (short whence, ACE_OFF_T start, ACE_OFF_T len) -{ -// ACE_TRACE ("ACE_File_Lock::tryacquire_read"); - return ACE_OS::flock_tryrdlock (&this->lock_, whence, start, len); -} - -ACE_INLINE int -ACE_File_Lock::tryacquire_write (short whence, ACE_OFF_T start, ACE_OFF_T len) -{ -// ACE_TRACE ("ACE_File_Lock::tryacquire_write"); - return ACE_OS::flock_trywrlock (&this->lock_, whence, start, len); -} - -ACE_INLINE int -ACE_File_Lock::tryacquire_write_upgrade (short whence, - ACE_OFF_T start, - ACE_OFF_T len) -{ -// ACE_TRACE ("ACE_File_Lock::tryacquire_write_upgrade"); - return ACE_OS::flock_trywrlock (&this->lock_, whence, start, len); -} - -ACE_INLINE int -ACE_File_Lock::tryacquire (short whence, ACE_OFF_T start, ACE_OFF_T len) -{ -// ACE_TRACE ("ACE_File_Lock::tryacquire"); - return this->tryacquire_write (whence, start, len); -} - -ACE_INLINE int -ACE_File_Lock::acquire_write (short whence, ACE_OFF_T start, ACE_OFF_T len) -{ -// ACE_TRACE ("ACE_File_Lock::acquire_write"); - return ACE_OS::flock_wrlock (&this->lock_, whence, start, len); -} - -ACE_INLINE int -ACE_File_Lock::acquire (short whence, ACE_OFF_T start, ACE_OFF_T len) -{ -// ACE_TRACE ("ACE_File_Lock::acquire"); - return this->acquire_write (whence, start, len); -} - -ACE_INLINE int -ACE_File_Lock::release (short whence, ACE_OFF_T start, ACE_OFF_T len) -{ -// ACE_TRACE ("ACE_File_Lock::release"); - return ACE_OS::flock_unlock (&this->lock_, whence, start, len); -} - -ACE_INLINE int -ACE_File_Lock::remove (bool unlink_file) -{ -// ACE_TRACE ("ACE_File_Lock::remove"); - - int result = 0; - - if (!this->removed_) - { - this->removed_ = true; - result = ACE_OS::flock_destroy (&this->lock_, - unlink_file); - } - return result; -} - -ACE_INLINE ACE_HANDLE -ACE_File_Lock::get_handle (void) const -{ -// ACE_TRACE ("ACE_File_Lock::get_handle"); - return this->lock_.handle_; -} - -ACE_INLINE void -ACE_File_Lock::set_handle (ACE_HANDLE h) -{ -// ACE_TRACE ("ACE_File_Lock::set_handle"); - this->lock_.handle_ = h; - this->removed_ = false; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Filecache.cpp b/deps/acelite/ace/Filecache.cpp deleted file mode 100644 index 6916367bc..000000000 --- a/deps/acelite/ace/Filecache.cpp +++ /dev/null @@ -1,749 +0,0 @@ -#include "ace/Filecache.h" -#include "ace/Object_Manager.h" -#include "ace/Log_Category.h" -#include "ace/ACE.h" -#include "ace/Guard_T.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_NS_time.h" -#include "ace/OS_NS_unistd.h" -#include "ace/OS_NS_fcntl.h" -#include "ace/Truncate.h" - -#if defined (ACE_WIN32) -// Specifies no sharing flags. -#define R_MASK ACE_DEFAULT_OPEN_PERMS -#define W_MASK 0 -#else -#define R_MASK S_IRUSR|S_IRGRP|S_IROTH -#define W_MASK S_IRUSR|S_IRGRP|S_IROTH|S_IWUSR|S_IWGRP|S_IWOTH -#endif /* ACE_WIN32 */ - -#if defined (ACE_WIN32) -// See if you can get rid of some of these. -#define READ_FLAGS (FILE_FLAG_SEQUENTIAL_SCAN | \ - FILE_FLAG_OVERLAPPED | \ - O_RDONLY) -// static const int RCOPY_FLAGS = (FILE_FLAG_SEQUENTIAL_SCAN | -// O_RDONLY); -#define WRITE_FLAGS (FILE_FLAG_SEQUENTIAL_SCAN | \ - FILE_FLAG_OVERLAPPED | \ - O_RDWR | O_CREAT | O_TRUNC) -// static const int WCOPY_FLAGS = (FILE_FLAG_SEQUENTIAL_SCAN | -// O_RDWR | O_CREAT | O_TRUNC); -#else -#define READ_FLAGS O_RDONLY -// static const int RCOPY_FLAGS = O_RDONLY; -#define WRITE_FLAGS (O_RDWR | O_CREAT | O_TRUNC) -// static const int WCOPY_FLAGS = O_RDWR | O_CREAT | O_TRUNC; -#endif /* ACE_WIN32 */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// static data members -ACE_Filecache *ACE_Filecache::cvf_ = 0; - -void -ACE_Filecache_Handle::init (void) -{ - this->file_ = 0; - this->handle_ = ACE_INVALID_HANDLE; -} - -ACE_Filecache_Handle::ACE_Filecache_Handle (void) - : file_ (0), handle_ (0) -{ - this->init (); -} - -ACE_Filecache_Handle::ACE_Filecache_Handle (const ACE_TCHAR *filename, - ACE_Filecache_Flag mapit) - : file_ (0), handle_ (0) -{ - this->init (); - // Fetch the file from the Virtual_Filesystem let the - // Virtual_Filesystem do the work of cache coherency. - - // Filecache will also do the acquire, since it holds the lock at - // that time. - this->file_ = ACE_Filecache::instance ()->fetch (filename, mapit); -} - -ACE_Filecache_Handle::ACE_Filecache_Handle (const ACE_TCHAR *filename, - int size, - ACE_Filecache_Flag ) - : file_ (0), handle_ (0) -{ - this->init (); - - if (size == 0) - ACE_Filecache::instance ()->remove (filename); - else - { - // Since this is being opened for a write, simply create a new - // ACE_Filecache_Object now, and let the destructor add it into CVF - // later - - // Filecache will also do the acquire, since it holds the lock at - // that time. - this->file_ = ACE_Filecache::instance ()->create (filename, size); - } -} - -ACE_Filecache_Handle::~ACE_Filecache_Handle (void) -{ - if (this->handle_ != ACE_INVALID_HANDLE) - // this was dup ()'d - ACE_OS::close (this->handle_); - - ACE_Filecache::instance ()->finish (this->file_); -} - -void * -ACE_Filecache_Handle::address (void) const -{ - return this->file_ == 0 ? 0 : this->file_->address (); -} - -ACE_HANDLE -ACE_Filecache_Handle::handle (void) const -{ - if (this->handle_ == ACE_INVALID_HANDLE && this->file_ != 0) - { - ACE_Filecache_Handle *mutable_this = - const_cast (this); - mutable_this->handle_ = ACE_OS::dup (this->file_->handle ()); - } - return this->handle_; -} - -int -ACE_Filecache_Handle::error (void) const -{ - if (this->file_ == 0) - return -1; - else - return this->file_->error (); -} - -ACE_OFF_T -ACE_Filecache_Handle::size (void) const -{ - if (this->file_ == 0) - return -1; - else - return this->file_->size (); -} - -// ------------------ -// ACE_Filecache_Hash -// ------------------ - -#define ACE_Filecache_Hash \ - ACE_Hash_Map_Manager_Ex, ACE_Equal_To, ACE_Null_Mutex> -#define ACE_Filecache_Hash_Entry \ - ACE_Hash_Map_Entry - -template <> -ACE_Filecache_Hash_Entry::ACE_Hash_Map_Entry ( - const ACE_TCHAR *const &ext_id, - ACE_Filecache_Object *const &int_id, - ACE_Filecache_Hash_Entry *next, - ACE_Filecache_Hash_Entry *prev) - : ext_id_ (ext_id - ? ACE_OS::strdup (ext_id) - : ACE_OS::strdup (ACE_TEXT (""))), - int_id_ (int_id), - next_ (next), - prev_ (prev) -{ -} - -template <> -ACE_Filecache_Hash_Entry::ACE_Hash_Map_Entry (ACE_Filecache_Hash_Entry *next, - ACE_Filecache_Hash_Entry *prev) - : ext_id_ (0), - int_id_ (0), - next_ (next), - prev_ (prev) -{ -} - -template <> -ACE_Filecache_Hash_Entry::~ACE_Hash_Map_Entry (void) -{ -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free ((void *) ext_id_); -#else - ACE_OS::free ((void *) ext_id_); -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -// We need these template specializations since KEY is defined as a -// ACE_TCHAR*, which doesn't have a hash() or equal() method defined on it. - -template <> -unsigned long -ACE_Filecache_Hash::hash (const ACE_TCHAR *const &ext_id) -{ - return ACE::hash_pjw (ext_id); -} - -template <> -int -ACE_Filecache_Hash::equal (const ACE_TCHAR *const &id1, - const ACE_TCHAR *const &id2) -{ - return ACE_OS::strcmp (id1, id2) == 0; -} - -#undef ACE_Filecache_Hash -#undef ACE_Filecache_Hash_Entry - - -// ------------- -// ACE_Filecache -// ------------- - -ACE_Filecache * -ACE_Filecache::instance (void) -{ - // Double check locking pattern. - if (ACE_Filecache::cvf_ == 0) - { - ACE_SYNCH_RW_MUTEX &lock = - *ACE_Managed_Object::get_preallocated_object - (ACE_Object_Manager::ACE_FILECACHE_LOCK); - ACE_GUARD_RETURN (ACE_SYNCH_RW_MUTEX, ace_mon, lock, 0); - - // @@ James, please check each of the ACE_NEW_RETURN calls to - // make sure that it is safe to return if allocation fails. - if (ACE_Filecache::cvf_ == 0) - ACE_NEW_RETURN (ACE_Filecache::cvf_, - ACE_Filecache, - 0); - } - - return ACE_Filecache::cvf_; -} - -ACE_Filecache::ACE_Filecache (void) - : size_ (ACE_DEFAULT_VIRTUAL_FILESYSTEM_TABLE_SIZE), - hash_ (size_) -{ -} - -ACE_Filecache::~ACE_Filecache (void) -{ -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Filecache) - -ACE_Filecache_Object * -ACE_Filecache::insert_i (const ACE_TCHAR *filename, - ACE_SYNCH_RW_MUTEX &filelock, - int mapit) -{ - ACE_Filecache_Object *handle = 0; - - if (this->hash_.find (filename, handle) == -1) - { - ACE_NEW_RETURN (handle, - ACE_Filecache_Object (filename, filelock, 0, mapit), - 0); - - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT (" (%t) CVF: creating %s\n"), filename)); - - if (this->hash_.bind (filename, handle) == -1) - { - delete handle; - handle = 0; - } - } - else - handle = 0; - - return handle; -} - -ACE_Filecache_Object * -ACE_Filecache::remove_i (const ACE_TCHAR *filename) -{ - ACE_Filecache_Object *handle = 0; - - // Disassociate file from the cache. - if (this->hash_.unbind (filename, handle) == 0) - { - handle->stale_ = 1; - - // Try a lock. If it succeeds, we can delete it now. - // Otherwise, it will clean itself up later. - if (handle->lock_.tryacquire_write () == 0) - { - delete handle; - handle = 0; - } - } - else - handle = 0; - - return handle; -} - -ACE_Filecache_Object * -ACE_Filecache::update_i (const ACE_TCHAR *filename, - ACE_SYNCH_RW_MUTEX &filelock, - int mapit) -{ - ACE_Filecache_Object *handle = 0; - - handle = this->remove_i (filename); - handle = this->insert_i (filename, filelock, mapit); - - return handle; -} - -int -ACE_Filecache::find (const ACE_TCHAR *filename) -{ - return this->hash_.find (filename); -} - - -ACE_Filecache_Object * -ACE_Filecache::remove (const ACE_TCHAR *filename) -{ - ACE_Filecache_Object *handle = 0; - - ACE_OFF_T loc = ACE::hash_pjw (filename) % this->size_; - ACE_SYNCH_RW_MUTEX &hashlock = this->hash_lock_[loc]; - // ACE_SYNCH_RW_MUTEX &filelock = this->file_lock_[loc]; - - if (this->hash_.find (filename, handle) != -1) - { - ACE_WRITE_GUARD_RETURN (ACE_SYNCH_RW_MUTEX, - ace_mon, - hashlock, - 0); - - return this->remove_i (filename); - } - - return 0; -} - - -ACE_Filecache_Object * -ACE_Filecache::fetch (const ACE_TCHAR *filename, int mapit) -{ - ACE_Filecache_Object *handle = 0; - - ACE_OFF_T loc = ACE::hash_pjw (filename) % this->size_; - ACE_SYNCH_RW_MUTEX &hashlock = this->hash_lock_[loc]; - ACE_SYNCH_RW_MUTEX &filelock = this->file_lock_[loc]; - - filelock.acquire_read (); - - if (this->hash_.find (filename, handle) == -1) - { - ACE_WRITE_GUARD_RETURN (ACE_SYNCH_RW_MUTEX, - ace_mon, - hashlock, - 0); - - // Second check in the method call - handle = this->insert_i (filename, filelock, mapit); - - if (handle == 0) - filelock.release (); - } - else - { - if (handle->update ()) - { - { - // Double check locking pattern - ACE_WRITE_GUARD_RETURN (ACE_SYNCH_RW_MUTEX, - ace_mon, - hashlock, - 0); - - // Second check in the method call - handle = this->update_i (filename, filelock, mapit); - - if (handle == 0) - filelock.release (); - } - } - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT (" (%t) CVF: found %s\n"), filename)); - } - - return handle; -} - -ACE_Filecache_Object * -ACE_Filecache::create (const ACE_TCHAR *filename, int size) -{ - ACE_Filecache_Object *handle = 0; - - ACE_OFF_T loc = ACE::hash_pjw (filename) % this->size_; - ACE_SYNCH_RW_MUTEX &filelock = this->file_lock_[loc]; - - ACE_NEW_RETURN (handle, - ACE_Filecache_Object (filename, size, filelock), - 0); - handle->acquire (); - - return handle; -} - -ACE_Filecache_Object * -ACE_Filecache::finish (ACE_Filecache_Object *&file) -{ - if (file == 0) - return file; - - ACE_OFF_T loc = ACE::hash_pjw (file->filename_) % this->size_; - ACE_SYNCH_RW_MUTEX &hashlock = this->hash_lock_[loc]; - - if (file != 0) - switch (file->action_) - { - case ACE_Filecache_Object::ACE_WRITING: - { - ACE_WRITE_GUARD_RETURN (ACE_SYNCH_RW_MUTEX, - ace_mon, - hashlock, - 0); - - file->release (); - - this->remove_i (file->filename_); -#if 0 - int result = this->hash_.bind (file->filename (), file); - - if (result == 0) - file->acquire (); -#else - // Last one using a stale file is resposible for deleting it. - if (file->stale_) - { - // Try a lock. If it succeds, we can delete it now. - // Otherwise, it will clean itself up later. - if (file->lock_.tryacquire_write () == 0) - { - delete file; - file = 0; - } - } -#endif - } - - break; - default: - file->release (); - - // Last one using a stale file is resposible for deleting it. - if (file->stale_) - { - // Try a lock. If it succeds, we can delete it now. - // Otherwise, it will clean itself up later. - if (file->lock_.tryacquire_write () == 0) - { - delete file; - file = 0; - } - } - - break; - } - - return file; -} - -void -ACE_Filecache_Object::init (void) -{ - this->filename_[0] = '\0'; - this->handle_ = ACE_INVALID_HANDLE; - this->error_ = ACE_SUCCESS; - this->tempname_ = 0; - this->size_ = 0; - - ACE_OS::memset (&(this->stat_), 0, sizeof (this->stat_)); -} - -ACE_Filecache_Object::ACE_Filecache_Object (void) - : tempname_ (0), - mmap_ (), - handle_ (0), - // stat_ (), - size_ (0), - action_ (0), - error_ (0), - stale_ (0), - // sa_ (), - junklock_ (), - lock_ (junklock_) -{ - this->init (); -} - -ACE_Filecache_Object::ACE_Filecache_Object (const ACE_TCHAR *filename, - ACE_SYNCH_RW_MUTEX &lock, - LPSECURITY_ATTRIBUTES sa, - int mapit) - : tempname_ (0), - mmap_ (), - handle_ (0), - // stat_ (), - size_ (0), - action_ (0), - error_ (0), - stale_ (0), - sa_ (sa), - junklock_ (), - lock_ (lock) -{ - this->init (); - - // ASSERT strlen(filename) < sizeof (this->filename_) - ACE_OS::strcpy (this->filename_, filename); - this->action_ = ACE_Filecache_Object::ACE_READING; - // place ourselves into the READING state - - // Can we access the file? - if (ACE_OS::access (this->filename_, R_OK) == -1) - { - this->error_i (ACE_Filecache_Object::ACE_ACCESS_FAILED); - return; - } - - // Can we stat the file? - if (ACE_OS::stat (this->filename_, &this->stat_) == -1) - { - this->error_i (ACE_Filecache_Object::ACE_STAT_FAILED); - return; - } - - this->size_ = ACE_Utils::truncate_cast (this->stat_.st_size); - this->tempname_ = this->filename_; - - // Can we open the file? - this->handle_ = ACE_OS::open (this->tempname_, - READ_FLAGS, R_MASK, this->sa_); - if (this->handle_ == ACE_INVALID_HANDLE) - { - this->error_i (ACE_Filecache_Object::ACE_OPEN_FAILED, - ACE_TEXT ("ACE_Filecache_Object::ctor: open")); - return; - } - - if (mapit) - { - // Can we map the file? - if (this->mmap_.map (this->handle_, static_cast (-1), - PROT_READ, ACE_MAP_PRIVATE, 0, 0, this->sa_) != 0) - { - this->error_i (ACE_Filecache_Object::ACE_MEMMAP_FAILED, - ACE_TEXT ("ACE_Filecache_Object::ctor: map")); - ACE_OS::close (this->handle_); - this->handle_ = ACE_INVALID_HANDLE; - return; - } - } - - // Ok, finished! - this->action_ = ACE_Filecache_Object::ACE_READING; -} - -ACE_Filecache_Object::ACE_Filecache_Object (const ACE_TCHAR *filename, - ACE_OFF_T size, - ACE_SYNCH_RW_MUTEX &lock, - LPSECURITY_ATTRIBUTES sa) - : stale_ (0), - sa_ (sa), - lock_ (lock) -{ - this->init (); - - this->size_ = size; - ACE_OS::strcpy (this->filename_, filename); - this->action_ = ACE_Filecache_Object::ACE_WRITING; - - // Can we access the file? - if (ACE_OS::access (this->filename_, R_OK|W_OK) == -1 - // Does it exist? - && ACE_OS::access (this->filename_, F_OK) != -1) - { - // File exists, but we cannot access it. - this->error_i (ACE_Filecache_Object::ACE_ACCESS_FAILED); - return; - } - - this->tempname_ = this->filename_; - - // Can we open the file? - this->handle_ = ACE_OS::open (this->tempname_, WRITE_FLAGS, W_MASK, this->sa_); - if (this->handle_ == ACE_INVALID_HANDLE) - { - this->error_i (ACE_Filecache_Object::ACE_OPEN_FAILED, - ACE_TEXT ("ACE_Filecache_Object::acquire: open")); - return; - } - - // Can we write? - if (ACE_OS::pwrite (this->handle_, "", 1, this->size_ - 1) != 1) - { - this->error_i (ACE_Filecache_Object::ACE_WRITE_FAILED, - ACE_TEXT ("ACE_Filecache_Object::acquire: write")); - ACE_OS::close (this->handle_); - return; - } - - // Can we map? - if (this->mmap_.map (this->handle_, this->size_, PROT_RDWR, MAP_SHARED, - 0, 0, this->sa_) != 0) - { - this->error_i (ACE_Filecache_Object::ACE_MEMMAP_FAILED, - ACE_TEXT ("ACE_Filecache_Object::acquire: map")); - ACE_OS::close (this->handle_); - } - - // Ok, done! -} - -ACE_Filecache_Object::~ACE_Filecache_Object (void) -{ - if (this->error_ == ACE_SUCCESS) - { - this->mmap_.unmap (); - ACE_OS::close (this->handle_); - this->handle_ = ACE_INVALID_HANDLE; - } - - this->lock_.release (); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Filecache_Object) - -int -ACE_Filecache_Object::acquire (void) -{ - return this->lock_.tryacquire_read (); -} - -int -ACE_Filecache_Object::release (void) -{ - if (this->action_ == ACE_WRITING) - { - // We are safe since only one thread has a writable Filecache_Object - -#if 0 - ACE_HANDLE original = ACE_OS::open (this->filename_, WRITE_FLAGS, W_MASK, - this->sa_); - if (original == ACE_INVALID_HANDLE) - this->error_ = ACE_Filecache_Object::ACE_OPEN_FAILED; - else if (ACE_OS::write (original, this->mmap_.addr (), - this->size_) == -1) - { - this->error_ = ACE_Filecache_Object::ACE_WRITE_FAILED; - ACE_OS::close (original); - ACE_OS::unlink (this->filename_); - } - else if (ACE_OS::stat (this->filename_, &this->stat_) == -1) - this->error_ = ACE_Filecache_Object::ACE_STAT_FAILED; -#endif - - this->mmap_.unmap (); - ACE_OS::close (this->handle_); - this->handle_ = ACE_INVALID_HANDLE; - -#if 0 - // Leave the file in an acquirable state. - this->handle_ = ACE_OS::open (this->tempname_, READ_FLAGS, R_MASK); - if (this->handle_ == ACE_INVALID_HANDLE) - { - this->error_i (ACE_Filecache_Object::ACE_OPEN_FAILED, - "ACE_Filecache_Object::acquire: open"); - } - else if (this->mmap_.map (this->handle_, -1, - PROT_READ, - ACE_MAP_PRIVATE, - 0, - 0, - this->sa_) != 0) - { - this->error_i (ACE_Filecache_Object::ACE_MEMMAP_FAILED, - "ACE_Filecache_Object::acquire: map"); - ACE_OS::close (this->handle_); - this->handle_ = ACE_INVALID_HANDLE; - } - - this->action_ = ACE_Filecache_Object::ACE_READING; -#endif - } - - return this->lock_.release (); -} - -int -ACE_Filecache_Object::error (void) const -{ - // The existence of the object means a read lock is being held. - return this->error_; -} - -int -ACE_Filecache_Object::error_i (int error_value, const ACE_TCHAR *s) -{ - ACE_UNUSED_ARG (s); - ACELIB_ERROR ((LM_ERROR, ACE_TEXT ("%p.\n"), s)); - this->error_ = error_value; - return error_value; -} - -const ACE_TCHAR * -ACE_Filecache_Object::filename (void) const -{ - // The existence of the object means a read lock is being held. - return this->filename_; -} - -ACE_OFF_T -ACE_Filecache_Object::size (void) const -{ - // The existence of the object means a read lock is being held. - return this->size_; -} - -ACE_HANDLE -ACE_Filecache_Object::handle (void) const -{ - // The existence of the object means a read lock is being held. - return this->handle_; -} - -void * -ACE_Filecache_Object::address (void) const -{ - // The existence of the object means a read lock is being held. - return this->mmap_.addr (); -} - -int -ACE_Filecache_Object::update (void) const -{ - // The existence of the object means a read lock is being held. - int result; - ACE_stat statbuf; - - if (ACE_OS::stat (this->filename_, &statbuf) == -1) - result = 1; - else - result = ACE_OS::difftime (this->stat_.st_mtime, statbuf.st_mtime) < 0; - - return result; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Filecache.h b/deps/acelite/ace/Filecache.h deleted file mode 100644 index 4596edab2..000000000 --- a/deps/acelite/ace/Filecache.h +++ /dev/null @@ -1,355 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Filecache.h - * - * @author James Hu - */ -//============================================================================= - - -#ifndef ACE_FILECACHE_H -#define ACE_FILECACHE_H - -#include /**/ "ace/pre.h" - -#include "ace/Mem_Map.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Hash_Map_Manager_T.h" -#include "ace/Null_Mutex.h" -#include "ace/Synch_Traits.h" -#include "ace/RW_Thread_Mutex.h" -#include "ace/OS_NS_sys_stat.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -enum ACE_Filecache_Flag -{ - ACE_NOMAP = 0, - ACE_MAPIT = 1 -}; - -class ACE_Filecache_Object; - -/** - * @class ACE_Filecache_Handle - * - * @brief - * Abstraction over a real file. This is meant to be the entry - * point into the Cached Virtual Filesystem. - * - * This is a cached filesystem implementation based loosely on the - * implementation of JAWS_File. The interfaces will be nearly the - * same. The under-the-hood implementation should hopefully be a - * much faster thing. - * These will be given their own implementations later. For now, we - * borrow the implementation provided by JAWS. - * On creation, the cache is checked, and reference count is - * incremented. On destruction, reference count is decremented. If - * the reference count is 0, the file is removed from the cache. - * E.g. 1, - * { - * ACE_Filecache_Handle foo("foo.html"); - * this->peer ().send (foo.address (), foo.size ()); - * } - * E.g. 2, - * { - * ACE_Filecache_Handle foo("foo.html"); - * io->transmitfile (foo.handle (), this->peer ().handle ()); - * } - * E.g. 3, - * { - * ACE_Filecache_Handle foo("foo.html", content_length); - * this->peer ().recv (foo.address (), content_length); - * } - * TODO: - */ -class ACE_Export ACE_Filecache_Handle -{ - // (1) Get rid of the useless copying of files when reading. - // Although it does make sure the file you send isn't being changed, - // it doesn't make sure the file is in a sensible state before - // sending it. - // - // Alternative: if the file get's trashed while it is being shipped, - // let the client request the file again. The cache should have an - // updated copy by that point. - // - // (2) Use hashing for locating files. This means I need a hastable - // implementation with buckets. - // - // (3) Only lock when absolutely necessary. JAWS_Virtual_Filesystem was - // rather conservative, but for some reason it still ran into problems. - // Since this design should be simpler, problems should be easier to spot. - // -public: - - /// Query cache for file, and acquire it. Assumes the file is being - /// opened for reading. - ACE_Filecache_Handle (const ACE_TCHAR *filename, - ACE_Filecache_Flag mapit = ACE_MAPIT); - - /** - * Create new entry, and acquire it. Presence of SIZE assumes the - * file is being opened for writing. If SIZE is zero, assumes the - * file is to be removed from the cache. - */ - ACE_Filecache_Handle (const ACE_TCHAR *filename, - int size, - ACE_Filecache_Flag mapit = ACE_MAPIT); - - /// Closes any open handles, release acquired file. - ~ACE_Filecache_Handle (void); - - /// Base address of memory mapped file. - void *address (void) const; - - /// A handle (e.g., UNIX file descriptor, or NT file handle). - ACE_HANDLE handle (void) const; - - /// Any associated error in handle creation and acquisition. - int error (void) const; - - /// The size of the file. - ACE_OFF_T size (void) const; - -protected: - /// Default do nothing constructor. Prevent it from being called. - ACE_Filecache_Handle (void); - - /// Common initializations for constructors. - void init (void); - -public: - /// These come from ACE_Filecache_Object, which is an internal class. - enum - { - ACE_SUCCESS = 0, - ACE_ACCESS_FAILED, - ACE_OPEN_FAILED, - ACE_COPY_FAILED, - ACE_STAT_FAILED, - ACE_MEMMAP_FAILED, - ACE_WRITE_FAILED - }; - -private: - /// A reference to the low level instance. - ACE_Filecache_Object *file_; - - /// A dup'd version of the one from file_. - ACE_HANDLE handle_; -}; - -typedef ACE_Hash_Map_Manager_Ex, ACE_Equal_To, ACE_Null_Mutex> - ACE_Filecache_Hash; - -typedef ACE_Hash_Map_Entry ACE_Filecache_Hash_Entry; - -/** - * @class ACE_Filecache - * - * @brief - * A hash table holding the information about entry point into - * the Cached Virtual Filesystem. On insertion, the reference - * count is incremented. On destruction, reference count is - * decremented. - */ -class ACE_Export ACE_Filecache -{ -public: - /// Singleton pattern. - static ACE_Filecache *instance (void); - - ~ACE_Filecache (void); - - /// Returns 0 if the file associated with ``filename'' is in the cache, - /// or -1 if not. - int find (const ACE_TCHAR *filename); - - /// Return the file associated with ``filename'' if it is in the cache, - /// or create if not. - ACE_Filecache_Object *fetch (const ACE_TCHAR *filename, int mapit = 1); - - /// Remove the file associated with ``filename'' from the cache. - ACE_Filecache_Object *remove (const ACE_TCHAR *filename); - - /// Create a new Filecache_Object, returns it. - ACE_Filecache_Object *create (const ACE_TCHAR *filename, int size); - - /// Release an acquired Filecache_Object, returns it again or NULL if it - /// was deleted. - ACE_Filecache_Object *finish (ACE_Filecache_Object *&new_file); - - ACE_ALLOC_HOOK_DECLARE; - -protected: - ACE_Filecache_Object *insert_i (const ACE_TCHAR *filename, - ACE_SYNCH_RW_MUTEX &filelock, - int mapit); - ACE_Filecache_Object *remove_i (const ACE_TCHAR *filename); - ACE_Filecache_Object *update_i (const ACE_TCHAR *filename, - ACE_SYNCH_RW_MUTEX &filelock, - int mapit); - -public: - - enum - { - /// For this stupid implementation, use an array. Someday, use a - /// balanced search tree, or real hash table. - ACE_DEFAULT_VIRTUAL_FILESYSTEM_TABLE_SIZE = 512, - - /// This determines the highwater mark in megabytes for the cache. - /// This will be ignored for now. - ACE_DEFAULT_VIRTUAL_FILESYSTEM_CACHE_SIZE = 20 - }; - -protected: - /// Prevent it from being called. - ACE_Filecache (void); - -private: - ACE_OFF_T size_; - - /// The hash table - ACE_Filecache_Hash hash_; - - /// The reference to the instance - static ACE_Filecache *cvf_; - - // = Synchronization variables. - ACE_SYNCH_RW_MUTEX hash_lock_[ACE_DEFAULT_VIRTUAL_FILESYSTEM_TABLE_SIZE]; - ACE_SYNCH_RW_MUTEX file_lock_[ACE_DEFAULT_VIRTUAL_FILESYSTEM_TABLE_SIZE]; -}; - -/** - * @class ACE_Filecache_Object - * - * @brief - * Abstraction over a real file. This is what the Virtual - * Filesystem contains. This class is not intended for general - * consumption. Please consult a physician before attempting to - * use this class. - */ -class ACE_Export ACE_Filecache_Object -{ -public: - friend class ACE_Filecache; - - /// Creates a file for reading. - ACE_Filecache_Object (const ACE_TCHAR *filename, - ACE_SYNCH_RW_MUTEX &lock, - LPSECURITY_ATTRIBUTES sa = 0, - int mapit = 1); - - /// Creates a file for writing. - ACE_Filecache_Object (const ACE_TCHAR *filename, - ACE_OFF_T size, - ACE_SYNCH_RW_MUTEX &lock, - LPSECURITY_ATTRIBUTES sa = 0); - - /// Only if reference count is zero should this be called. - ~ACE_Filecache_Object (void); - - /// Increment the reference_count_. - int acquire (void); - - /// Decrement the reference_count_. - int release (void); - - // = error_ accessors - int error (void) const; - int error (int error_value, - const ACE_TCHAR *s = ACE_TEXT ("ACE_Filecache_Object")); - - /// filename_ accessor - const ACE_TCHAR *filename (void) const; - - /// handle_ accessor. - ACE_HANDLE handle (void) const; - - /// Base memory address for memory mapped file. - void *address (void) const; - - /// size_ accessor. - ACE_OFF_T size (void) const; - - /// True if file on disk is newer than cached file. - int update (void) const; - - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Prevent from being called. - ACE_Filecache_Object (void); - - /// Common initialization code, - void init (void); - -private: - /// Internal error logging method, no locking. - int error_i (int error_value, - const ACE_TCHAR *s = ACE_TEXT ("ACE_Filecache_Object")); - -public: - enum Creation_States - { - ACE_READING = 1, - ACE_WRITING = 2 - }; - - enum Error_Conditions - { - ACE_SUCCESS = 0, - ACE_ACCESS_FAILED, - ACE_OPEN_FAILED, - ACE_COPY_FAILED, - ACE_STAT_FAILED, - ACE_MEMMAP_FAILED, - ACE_WRITE_FAILED - }; - -private: - /// The temporary file name and the real file name. The real file is - /// copied into the temporary file for safety reasons. - ACE_TCHAR *tempname_; - ACE_TCHAR filename_[MAXPATHLEN + 1]; - - /// Holds the memory mapped version of the temporary file. - ACE_Mem_Map mmap_; - - /// The descriptor to the temporary file. - ACE_HANDLE handle_; - - /// Used to compare against the real file to test if an update is needed. - ACE_stat stat_; - ACE_OFF_T size_; - - /// Status indicators. - int action_; - int error_; - - /// If set to 1, means the object is flagged for removal. - int stale_; - - /// Security attribute object. - LPSECURITY_ATTRIBUTES sa_; - - /// The default initializer - ACE_SYNCH_RW_MUTEX junklock_; - - /// Provides a bookkeeping mechanism for users of this object. - ACE_SYNCH_RW_MUTEX &lock_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#endif /* ACE_FILECACHE_H */ diff --git a/deps/acelite/ace/Flag_Manip.cpp b/deps/acelite/ace/Flag_Manip.cpp deleted file mode 100644 index 0b5ec2d0e..000000000 --- a/deps/acelite/ace/Flag_Manip.cpp +++ /dev/null @@ -1,104 +0,0 @@ -#include "ace/Flag_Manip.h" - -#if defined (ACE_LACKS_FCNTL) -# include "ace/OS_NS_stropts.h" -# include "ace/OS_NS_errno.h" -#endif /* ACE_LACKS_FCNTL */ - -#if defined (ACE_LACKS_IOCTL) -# include "ace/OS_NS_devctl.h" -#endif - -#if !defined (__ACE_INLINE__) -#include "ace/Flag_Manip.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (CYGWIN32) -# include "ace/os_include/os_termios.h" -#endif /* CYGWIN32 */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Flags are file status flags to turn on. - -int -ACE::set_flags (ACE_HANDLE handle, int flags) -{ - ACE_TRACE ("ACE::set_flags"); -#if defined (ACE_LACKS_FCNTL) - switch (flags) - { - case ACE_NONBLOCK: - // nonblocking argument (1) - // blocking: (0) - { - int nonblock = 1; -# if defined (ACE_LACKS_IOCTL) - int dev_info; - return ACE_OS::posix_devctl (handle, FIONBIO, &nonblock, - sizeof nonblock, &dev_info); -# else - return ACE_OS::ioctl (handle, FIONBIO, &nonblock); -# endif - } - default: - ACE_NOTSUP_RETURN (-1); - } -#else - int val = ACE_OS::fcntl (handle, F_GETFL, 0); - - if (val == -1) - return -1; - - // Turn on flags. - ACE_SET_BITS (val, flags); - - if (ACE_OS::fcntl (handle, F_SETFL, val) == -1) - return -1; - else - return 0; -#endif /* ACE_LACKS_FCNTL */ -} - -// Flags are the file status flags to turn off. - -int -ACE::clr_flags (ACE_HANDLE handle, int flags) -{ - ACE_TRACE ("ACE::clr_flags"); -#if defined (ACE_LACKS_FCNTL) - switch (flags) - { - case ACE_NONBLOCK: - // nonblocking argument (1) - // blocking: (0) - { - int nonblock = 0; -# if defined (ACE_LACKS_IOCTL) - int dev_info; - return ACE_OS::posix_devctl (handle, FIONBIO, &nonblock, - sizeof nonblock, &dev_info); -# else - return ACE_OS::ioctl (handle, FIONBIO, &nonblock); -# endif - } - default: - ACE_NOTSUP_RETURN (-1); - } -#else - int val = ACE_OS::fcntl (handle, F_GETFL, 0); - - if (val == -1) - return -1; - - // Turn flags off. - ACE_CLR_BITS (val, flags); - - if (ACE_OS::fcntl (handle, F_SETFL, val) == -1) - return -1; - else - return 0; -#endif /* ACE_LACKS_FCNTL */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Flag_Manip.h b/deps/acelite/ace/Flag_Manip.h deleted file mode 100644 index f9324dd34..000000000 --- a/deps/acelite/ace/Flag_Manip.h +++ /dev/null @@ -1,56 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Flag_Manip.h - * - * This class includes the functions used for the Flag Manipulation. - * - * @author Priyanka Gontla - */ -//============================================================================= - -#ifndef ACE_FLAG_MANIP_H -#define ACE_FLAG_MANIP_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Global_Macros.h" -#include "ace/os_include/os_fcntl.h" /* For values passed to these methods */ - -#if defined (ACE_EXPORT_MACRO) -# undef ACE_EXPORT_MACRO -#endif -#define ACE_EXPORT_MACRO ACE_Export - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -namespace ACE -{ - // = Set/get/clear various flags related to I/O HANDLE. - /// Set flags associated with @a handle. - extern ACE_Export int set_flags (ACE_HANDLE handle, - int flags); - - /// Clear flags associated with @a handle. - extern ACE_Export int clr_flags (ACE_HANDLE handle, - int flags); - - /// Return the current setting of flags associated with @a handle. - ACE_NAMESPACE_INLINE_FUNCTION int get_flags (ACE_HANDLE handle); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Flag_Manip.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_FLAG_MANIP_H */ diff --git a/deps/acelite/ace/Flag_Manip.inl b/deps/acelite/ace/Flag_Manip.inl deleted file mode 100644 index f6def7748..000000000 --- a/deps/acelite/ace/Flag_Manip.inl +++ /dev/null @@ -1,23 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_fcntl.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Return flags currently associated with handle. -ACE_INLINE int -ACE::get_flags (ACE_HANDLE handle) -{ - ACE_TRACE ("ACE::get_flags"); - -#if defined (ACE_LACKS_FCNTL) - // ACE_OS::fcntl is not supported. It - // would be better to store ACE's notion of the flags - // associated with the handle, but this works for now. - ACE_UNUSED_ARG (handle); - return 0; -#else - return ACE_OS::fcntl (handle, F_GETFL, 0); -#endif /* ACE_LACKS_FCNTL */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Framework_Component.cpp b/deps/acelite/ace/Framework_Component.cpp deleted file mode 100644 index 513d378b9..000000000 --- a/deps/acelite/ace/Framework_Component.cpp +++ /dev/null @@ -1,284 +0,0 @@ -#include "ace/Framework_Component.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Framework_Component.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Object_Manager.h" -#include "ace/Log_Category.h" -#include "ace/DLL_Manager.h" -#include "ace/Recursive_Thread_Mutex.h" -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Framework_Component::~ACE_Framework_Component (void) -{ - ACE_TRACE ("ACE_Framework_Component::~ACE_Framework_Component"); - - ACE::strdelete (const_cast (this->dll_name_)); - ACE::strdelete (const_cast (this->name_)); -} - -/***************************************************************/ - -ACE_ALLOC_HOOK_DEFINE(ACE_Framework_Repository) - -sig_atomic_t ACE_Framework_Repository::shutting_down_ = 0; - -// Pointer to the Singleton instance. -ACE_Framework_Repository *ACE_Framework_Repository::repository_ = 0; - -ACE_Framework_Repository::~ACE_Framework_Repository (void) -{ - ACE_TRACE ("ACE_Framework_Repository::~ACE_Framework_Repository"); - this->close (); -} - -int -ACE_Framework_Repository::open (int size) -{ - ACE_TRACE ("ACE_Framework_Repository::open"); - - ACE_Framework_Component **temp = 0; - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_RETURN (temp, - static_cast (ACE_Allocator::instance()->malloc(sizeof(ACE_Framework_Component*) * size)), - -1); -#else - ACE_NEW_RETURN (temp, - ACE_Framework_Component *[size], - -1); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - this->component_vector_ = temp; - this->total_size_ = size; - return 0; -} - -int -ACE_Framework_Repository::close (void) -{ - ACE_TRACE ("ACE_Framework_Repository::close"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, -1); - - this->shutting_down_ = 1; - - if (this->component_vector_ != 0) - { - // Delete components in reverse order. - for (int i = this->current_size_ - 1; i >= 0; i--) - if (this->component_vector_[i]) - { - ACE_Framework_Component *s = - const_cast ( - this->component_vector_[i]); - - this->component_vector_[i] = 0; - delete s; - } - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(this->component_vector_); -#else - delete [] this->component_vector_; -#endif /* ACE_HAS_ALLOC_HOOKS */ - this->component_vector_ = 0; - this->current_size_ = 0; - } - - ACE_DLL_Manager::close_singleton (); - return 0; -} - -ACE_Framework_Repository * -ACE_Framework_Repository::instance (int size) -{ - ACE_TRACE ("ACE_Framework_Repository::instance"); - - if (ACE_Framework_Repository::repository_ == 0) - { - // Perform Double-Checked Locking Optimization. - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, - *ACE_Static_Object_Lock::instance (), 0)); - if (ACE_Framework_Repository::repository_ == 0) - { - if (ACE_Object_Manager::starting_up () || - !ACE_Object_Manager::shutting_down ()) - { - ACE_NEW_RETURN (ACE_Framework_Repository::repository_, - ACE_Framework_Repository (size), - 0); - } - } - } - - return ACE_Framework_Repository::repository_; -} - -void -ACE_Framework_Repository::close_singleton (void) -{ - ACE_TRACE ("ACE_Framework_Repository::close_singleton"); - - ACE_MT (ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon, - *ACE_Static_Object_Lock::instance ())); - - delete ACE_Framework_Repository::repository_; - ACE_Framework_Repository::repository_ = 0; -} - -int -ACE_Framework_Repository::register_component (ACE_Framework_Component *fc) -{ - ACE_TRACE ("ACE_Framework_Repository::register_component"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, -1); - int i; - - // Check to see if it's already registered - for (i = 0; i < this->current_size_; i++) - if (this->component_vector_[i] && - fc->this_ == this->component_vector_[i]->this_) - { - ACELIB_ERROR_RETURN ((LM_ERROR, - "AFR::register_component: error, compenent already registered\n"), - -1); - } - - if (i < this->total_size_) - { - this->component_vector_[i] = fc; - ++this->current_size_; - return 0; - } - - return -1; -} - -int -ACE_Framework_Repository::remove_component (const ACE_TCHAR *name) -{ - ACE_TRACE ("ACE_Framework_Repository::remove_component"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, -1); - int i; - - for (i = 0; i < this->current_size_; i++) - if (this->component_vector_[i] && - ACE_OS::strcmp (this->component_vector_[i]->name_, name) == 0) - { - delete this->component_vector_[i]; - this->component_vector_[i] = 0; - this->compact (); - return 0; - } - - return -1; -} - -int -ACE_Framework_Repository::remove_dll_components (const ACE_TCHAR *dll_name) -{ - ACE_TRACE ("ACE_Framework_Repository::remove_dll_components"); - - if (this->shutting_down_) - return this->remove_dll_components_i (dll_name); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, -1); - - return this->remove_dll_components_i (dll_name); -} - -int -ACE_Framework_Repository::remove_dll_components_i (const ACE_TCHAR *dll_name) -{ - ACE_TRACE ("ACE_Framework_Repository::remove_dll_components_i"); - - int i; - int retval = -1; - - for (i = 0; i < this->current_size_; i++) - if (this->component_vector_[i] && - ACE_OS::strcmp (this->component_vector_[i]->dll_name_, dll_name) == 0) - { - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("AFR::remove_dll_components_i (%s) ") - ACE_TEXT ("component \"%s\"\n"), - dll_name, this->component_vector_[i]->name_)); - delete this->component_vector_[i]; - this->component_vector_[i] = 0; - ++retval; - } - - this->compact (); - - return retval == -1 ? -1 : 0; -} - -void -ACE_Framework_Repository::compact (void) -{ - ACE_TRACE ("ACE_Framework_Repository::compact"); - - int i; - int start_hole; - int end_hole; - - do - { - start_hole = this->current_size_; - end_hole = this->current_size_; - - // Find hole - for (i = 0; i < this->current_size_; ++i) - { - if (this->component_vector_[i] == 0) - { - if (start_hole == this->current_size_) - { - start_hole = i; - end_hole = i; - } - else - end_hole = i; - } - else if (end_hole != this->current_size_) - break; - } - - if (start_hole != this->current_size_) - { - // move the contents and reset current_size_ - while (end_hole + 1 < this->current_size_) - { - this->component_vector_[start_hole++] = - this->component_vector_[++end_hole]; - } - // Since start_hole is now one past the last - // active slot. - this->current_size_ = start_hole; - } - - } while (start_hole != this->current_size_); -} - -void -ACE_Framework_Repository::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Framework_Repository::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Framework_Repository::ACE_Framework_Repository (int size) - : current_size_ (0) -{ - ACE_TRACE ("ACE_Framework_Repository::ACE_Framework_Repository"); - - if (this->open (size) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Framework_Repository"))); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Framework_Component.h b/deps/acelite/ace/Framework_Component.h deleted file mode 100644 index 8ffba2d5f..000000000 --- a/deps/acelite/ace/Framework_Component.h +++ /dev/null @@ -1,195 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Framework_Component.h - * - * A prototype mechanism that allows framework components, singletons - * such as ACE_Reactor, ACE_Proactor, etc, to be registered with a - * central repository managed by the ACE_Object_Manager or - * ACE_Service_Config that will handle destruction. - * - * This technique obviates changing ACE_Object_Manager and - * ACE_Service_Config everytime a new framework is added. Which also - * means that unused framework components don't need to linked into - * the final application which is important for applications with - * stringent footprint requirements. - * - * Framework components need only provide a static method, - * close_singleton() and add the ACE_REGISTER_FRAMEWORK_COMPONENT macro - * call to their instance() methods in order to participate. Components - * that don't have a close_singleton() method can also participate via - * template specialization of ACE_Framework_Component_T. - * - * This design uses the External Polymorphism pattern to avoid having - * to derive all framework components from a common base class that - * has virtual methods (this is crucial to avoid unnecessary overhead), - * and is based on the dump debugging implementation found in - * . - * - * @author Don Hinton . - */ -//============================================================================= - -#ifndef ACE_FRAMEWORK_COMPONENT_H -#define ACE_FRAMEWORK_COMPONENT_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/os_include/os_signal.h" -#include "ace/Thread_Mutex.h" -#include "ace/Copy_Disabled.h" -#include "ace/Synch_Traits.h" - -#define ACE_DEFAULT_FRAMEWORK_REPOSITORY_SIZE 1024 - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Framework_Component - * - * @brief Base class that defines a uniform interface for all managed - * framework components. - */ -class ACE_Export ACE_Framework_Component : private ACE_Copy_Disabled -{ -public: - friend class ACE_Framework_Repository; - - /// Constructor. - ACE_Framework_Component (void *_this, - const ACE_TCHAR *dll_name = 0, - const ACE_TCHAR *name = 0); - - /// Close the contained singleton. - virtual void close_singleton (void) = 0; - -protected: - /// Destructor. - virtual ~ACE_Framework_Component (void); - -private: - /// Pointer to the actual component. - const void *this_; - - /// Library associated with this component - const ACE_TCHAR *dll_name_; - - /// Component name - const ACE_TCHAR *name_; -}; - -/** - * @class ACE_Framework_Repository - * - * @brief Contains all framework components used by an application. - * - * This class contains a vector of ACE_Framework_Component *'s. On - * destruction, framework components are destroyed in the reverse order - * that they were added originally. - */ -class ACE_Export ACE_Framework_Repository : private ACE_Copy_Disabled -{ -public: - // This is just to silence a compiler warning about no public ctors - friend class ACE_Framework_Component; - - enum - { - DEFAULT_SIZE = ACE_DEFAULT_FRAMEWORK_REPOSITORY_SIZE - }; - - /// Close down the repository and free up dynamically allocated - /// resources. - ~ACE_Framework_Repository (void); - - /// Initialize the repository. - int open (int size = DEFAULT_SIZE); - - /// Close down the repository and free up dynamically allocated - /// resources, also called by dtor. - int close (void); - - /// Get pointer to a process-wide ACE_Framework_Repository. - static ACE_Framework_Repository *instance - (int size = ACE_Framework_Repository::DEFAULT_SIZE); - - /// Delete the dynamically allocated Singleton. - static void close_singleton (void); - - // = Search structure operations (all acquire locks as necessary). - - /// Insert a new component. Returns -1 when the repository is full - /// and 0 on success. - int register_component (ACE_Framework_Component *fc); - - /// Remove a component. Returns -1 on error or if component not found - /// and 0 on success. - int remove_component (const ACE_TCHAR *name); - - /// Remove all components associated with a particular dll. - int remove_dll_components (const ACE_TCHAR *dll_name); - - /// Return the current size of the repository. - int current_size (void) const; - - /// Return the total size of the repository. - int total_size (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Initialize the repository. - ACE_Framework_Repository (int size = ACE_Framework_Repository::DEFAULT_SIZE); - -private: - /// Actually removes the dll components, must be called with locks held. - int remove_dll_components_i (const ACE_TCHAR *dll_name); - - /// Compact component_vector_ after components have been removed__maintains - /// order. - void compact (void); - -private: - /// Contains all the framework components. - ACE_Framework_Component **component_vector_; - - /// Current number of components. - int current_size_; - - /// Maximum number of components. - int total_size_; - - /// Pointer to a process-wide ACE_Framework_Repository. - static ACE_Framework_Repository *repository_; - - /// Flag set when repository is the process of shutting down. This - /// is necessary to keep from self-deadlocking since some of - /// the components might make calls back to the repository to - /// unload their components, e.g., ACE_DLL_Manager. - static sig_atomic_t shutting_down_; - - /// Synchronization variable for the repository - ACE_SYNCH_MUTEX lock_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Framework_Component.inl" -#endif /* __ACE_INLINE__ */ - -// Include the templates classes at this point. -#include "ace/Framework_Component_T.h" - -#include /**/ "ace/post.h" -#endif /* ACE_FRAMEWORK_COMPONENT_H */ diff --git a/deps/acelite/ace/Framework_Component.inl b/deps/acelite/ace/Framework_Component.inl deleted file mode 100644 index e5d25bb2f..000000000 --- a/deps/acelite/ace/Framework_Component.inl +++ /dev/null @@ -1,36 +0,0 @@ -// -*- C++ -*- -#include "ace/ACE.h" -#include "ace/Guard_T.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Framework_Component::ACE_Framework_Component (void *_this, - const ACE_TCHAR *dll_name, - const ACE_TCHAR *name) - : this_ (_this), - dll_name_ (ACE::strnew (dll_name ? dll_name : ACE_TEXT (""))), - name_ (ACE::strnew (name ? name : ACE_TEXT (""))) -{ - ACE_TRACE ("ACE_Framework_Component::ctor"); -} - -/***************************************************************/ - -ACE_INLINE int -ACE_Framework_Repository::current_size (void) const -{ - ACE_TRACE ("ACE_Framework_Repository::current_size"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, const_cast (this->lock_), -1); - return this->current_size_; -} - -ACE_INLINE int -ACE_Framework_Repository::total_size (void) const -{ - ACE_TRACE ("ACE_Framework_Repository::total_size"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, const_cast (this->lock_), -1); - return this->total_size_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Framework_Component_T.cpp b/deps/acelite/ace/Framework_Component_T.cpp deleted file mode 100644 index abefe8325..000000000 --- a/deps/acelite/ace/Framework_Component_T.cpp +++ /dev/null @@ -1,37 +0,0 @@ -#ifndef ACE_FRAMEWORK_COMPONENT_T_CPP -#define ACE_FRAMEWORK_COMPONENT_T_CPP - -#include "ace/Framework_Component_T.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Framework_Component_T::ACE_Framework_Component_T (Concrete *concrete) - : ACE_Framework_Component ((void *) concrete, concrete->dll_name (), concrete->name ()) -{ - ACE_TRACE ("ACE_Framework_Component_T::ctor"); -} - -template -ACE_Framework_Component_T::~ACE_Framework_Component_T (void) -{ - ACE_TRACE ("ACE_Framework_Component_T::~ACE_Framework_Component_T"); - Concrete::close_singleton (); -} - -ACE_ALLOC_HOOK_DEFINE_Tt(ACE_Framework_Component_T) - -template void -ACE_Framework_Component_T::close_singleton (void) -{ - ACE_TRACE ("ACE_Framework_Component_T::close_singleton"); - Concrete::close_singleton (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_FRAMEWORK_COMPONENT_T_CPP */ diff --git a/deps/acelite/ace/Framework_Component_T.h b/deps/acelite/ace/Framework_Component_T.h deleted file mode 100644 index 5d5c39955..000000000 --- a/deps/acelite/ace/Framework_Component_T.h +++ /dev/null @@ -1,69 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Framework_Component_T.h - * - * @author Don Hinton - */ -//============================================================================= - -#ifndef ACE_FRAMEWORK_COMPONENT_T_H -#define ACE_FRAMEWORK_COMPONENT_T_H -#include /**/ "ace/pre.h" -#include "ace/Framework_Component.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Framework_Component_T - * - * @brief This class inherits the interface of the abstract - * ACE_Framework_Component class and is instantiated with the - * implementation of the concrete component class @c class Concrete. - * - * This design is similar to the Adapter and Decorator patterns - * from the ``Gang of Four'' book. Note that @c class Concrete - * need not inherit from a common class since ACE_Framework_Component - * provides the uniform virtual interface! (implementation based on - * ACE_Dumpable_Adapter in . - */ -template -class ACE_Framework_Component_T : public ACE_Framework_Component -{ -public: - /// Constructor. - ACE_Framework_Component_T (Concrete *concrete); - - /// Destructor. - ~ACE_Framework_Component_T (void); - - /// Close the contained singleton. - void close_singleton (void); - - ACE_ALLOC_HOOK_DECLARE; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -/// This macro should be called in the instance() method -/// of the Concrete class that will be managed. Along -/// with the appropriate template instantiation. -#define ACE_REGISTER_FRAMEWORK_COMPONENT(CLASS, INSTANCE) \ - ACE_Framework_Repository::instance ()->register_component \ - (new ACE_Framework_Component_T (INSTANCE)); - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Framework_Component_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Framework_Component_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_FRAMEWORK_COMPONENT_T_H */ diff --git a/deps/acelite/ace/Free_List.cpp b/deps/acelite/ace/Free_List.cpp deleted file mode 100644 index 36eed6d47..000000000 --- a/deps/acelite/ace/Free_List.cpp +++ /dev/null @@ -1,167 +0,0 @@ -#ifndef ACE_FREE_LIST_CPP -#define ACE_FREE_LIST_CPP - -#include "ace/Free_List.h" -#include "ace/Guard_T.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Free_List::~ACE_Free_List (void) -{ -} - -// Default constructor that takes in a preallocation number -// (), a low and high water mark ( and ) and an -// increment value () - -template -ACE_Locked_Free_List::ACE_Locked_Free_List (int mode, - size_t prealloc, - size_t lwm, - size_t hwm, - size_t inc) - : mode_ (mode), - free_list_ (0), - lwm_ (lwm), - hwm_ (hwm), - inc_ (inc), - size_ (0) -{ - this->alloc (prealloc); -} - -// Destructor - removes all the elements from the free_list - -template -ACE_Locked_Free_List::~ACE_Locked_Free_List (void) -{ - if (this->mode_ != ACE_PURE_FREE_LIST) - while (this->free_list_ != 0) - { - T *temp = this->free_list_; - this->free_list_ = this->free_list_->get_next (); - delete temp; - } -} - -// Inserts an element onto the free list (if we are allowed to manage -// elements withing and it pasts the high water mark, delete the -// element) - -template void -ACE_Locked_Free_List::add (T *element) -{ - ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_)); - - // Check to see that we not at the high water mark. - if (this->mode_ == ACE_PURE_FREE_LIST - || this->size_ < this->hwm_) - { - element->set_next (this->free_list_); - this->free_list_ = element; - this->size_++; - } - else - delete element; -} - -// Takes a element off the freelist and returns it. It creates -// new elements if we are allowed to do it and the size is at the low -// water mark. - -template T * -ACE_Locked_Free_List::remove (void) -{ - ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, 0)); - - // If we are at the low water mark, add some nodes - if (this->mode_ != ACE_PURE_FREE_LIST && this->size_ <= this->lwm_) - this->alloc (this->inc_); - - // Remove a node - T *temp = this->free_list_; - - if (temp != 0) - { - this->free_list_ = this->free_list_->get_next (); - this->size_--; - } - - return temp; -} - - -// Returns the current size of the free list - -template size_t -ACE_Locked_Free_List::size (void) -{ - return this->size_; -} - -// Resizes the free list to - -template void -ACE_Locked_Free_List::resize (size_t newsize) -{ - ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_)); - - // Check if we are allowed to resize - if (this->mode_ != ACE_PURE_FREE_LIST) - { - // Check to see if we grow or shrink - if (newsize < this->size_) - { - this->dealloc (this->size_ - newsize); - } - else - { - this->alloc (newsize - this->size_); - } - } -} - -// Allocates extra nodes for the freelist - -template void -ACE_Locked_Free_List::alloc (size_t n) -{ - for (; n > 0; n--) - { - T *temp = 0; - ACE_NEW (temp, T); - temp->set_next (this->free_list_); - this->free_list_ = temp; - this->size_++; - } -} - -// Removes and frees nodes from the freelist. - -template void -ACE_Locked_Free_List::dealloc (size_t n) -{ - for (; this->free_list_ != 0 && n > 0; - n--) - { - T *temp = this->free_list_; - this->free_list_ = this->free_list_->get_next (); - delete temp; - this->size_--; - } -} - -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Locked_Free_List) - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_FREE_LIST_CPP */ diff --git a/deps/acelite/ace/Free_List.h b/deps/acelite/ace/Free_List.h deleted file mode 100644 index 38ca93100..000000000 --- a/deps/acelite/ace/Free_List.h +++ /dev/null @@ -1,149 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Free_List.h - * - * @author Darrell Brunsch (brunsch@cs.wustl.edu) - */ -//============================================================================= - -#ifndef ACE_FREE_LIST_H -#define ACE_FREE_LIST_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Global_Macros.h" -#include "ace/Default_Constants.h" -#include "ace/os_include/os_stddef.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Free_List - * - * @brief Implements a free list. - * - * This class maintains a free list of nodes of type T. - */ -template -class ACE_Free_List -{ -public: - /// Destructor - removes all the elements from the free_list. - virtual ~ACE_Free_List (void); - - /// Inserts an element onto the free list (if it isn't past the high - /// water mark). - virtual void add (T *element) = 0; - - /// Takes a element off the freelist and returns it. It creates - /// new elements if the size is at or below the low water mark. - virtual T *remove (void) = 0; - - /// Returns the current size of the free list. - virtual size_t size (void) = 0; - - /// Resizes the free list to @a newsize. - virtual void resize (size_t newsize) = 0; -}; - -/** - * @class ACE_Locked_Free_List - * - * @brief Implements a free list. - * - * This class maintains a free list of nodes of type T. It - * depends on the type T having a get_next() and set_next() - * method. It maintains a mutex so the freelist can be used in - * a multithreaded program . - */ -template -class ACE_Locked_Free_List : public ACE_Free_List -{ -public: - /** - * Constructor takes a @a mode (i.e., ACE_FREE_LIST_WITH_POOL or - * ACE_PURE_FREE_LIST), a count of the number of nodes to - * @a prealloc, a low and high water mark (@a lwm and @a hwm) that - * indicate when to allocate more nodes, an increment value (@a inc) - * that indicates how many nodes to allocate when the list must - * grow. - */ - ACE_Locked_Free_List (int mode = ACE_FREE_LIST_WITH_POOL, - size_t prealloc = ACE_DEFAULT_FREE_LIST_PREALLOC, - size_t lwm = ACE_DEFAULT_FREE_LIST_LWM, - size_t hwm = ACE_DEFAULT_FREE_LIST_HWM, - size_t inc = ACE_DEFAULT_FREE_LIST_INC); - - /// Destructor - removes all the elements from the free_list. - virtual ~ACE_Locked_Free_List (void); - - /// Inserts an element onto the free list (if it isn't past the high - /// water mark). - virtual void add (T *element); - - /// Takes a element off the freelist and returns it. It creates - /// new elements if the size is at or below the low water mark. - virtual T *remove (void); - - /// Returns the current size of the free list. - virtual size_t size (void); - - /// Resizes the free list to @a newsize. - virtual void resize (size_t newsize); - - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Allocates @a n extra nodes for the freelist. - virtual void alloc (size_t n); - - /// Removes and frees @a n nodes from the freelist. - virtual void dealloc (size_t n); - - /// Free list operation mode, either ACE_FREE_LIST_WITH_POOL or - /// ACE_PURE_FREE_LIST. - int mode_; - - /// Pointer to the first node in the freelist. - T *free_list_; - - /// Low water mark. - size_t lwm_; - - /// High water mark. - size_t hwm_; - - /// Increment value. - size_t inc_; - - /// Keeps track of the size of the list. - size_t size_; - - /// Synchronization variable for ACE_Timer_Queue. - ACE_LOCK mutex_; - -private: - // = Don't allow these operations for now. - ACE_UNIMPLEMENTED_FUNC (ACE_Locked_Free_List (const ACE_Locked_Free_List &)) - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Locked_Free_List &)) -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Free_List.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Free_List.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_FREE_LIST_H */ diff --git a/deps/acelite/ace/Functor.cpp b/deps/acelite/ace/Functor.cpp deleted file mode 100644 index b5b13c921..000000000 --- a/deps/acelite/ace/Functor.cpp +++ /dev/null @@ -1,50 +0,0 @@ - -//============================================================================= -/** - * @file Functor.cpp - * - * Non-inlinable method definitions for non-templatized classes - * and template specializations implementing the GOF Command Pattern, - * and STL-style functors. - * - * @author Chris Gill - * - * Based on Command Pattern implementations originally done by - * - * Carlos O'Ryan - * Douglas C. Schmidt - * Sergio Flores-Gaitan - * - * and on STL-style functor implementations originally done by - * - * Irfan Pyarali - */ -//============================================================================= - - -#include "ace/Functor_T.h" -#include "ace/Functor.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Functor.inl" -#endif /* __ACE_INLINE__ */ - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Command_Base::~ACE_Command_Base (void) -{ -} - -ACE_Noop_Command::ACE_Noop_Command() -{ -} - -int -ACE_Noop_Command::execute(void*) -{ - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Functor.h b/deps/acelite/ace/Functor.h deleted file mode 100644 index 892096663..000000000 --- a/deps/acelite/ace/Functor.h +++ /dev/null @@ -1,498 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Functor.h - * - * Non-templatized classes and class template specializations for - * implementing function objects that are used in various places - * in ACE. There are currently two major categories of function - * objects in ACE: GoF Command Pattern objects, and STL-style - * functors for comparison of container elements. The command objects - * are invoked via an execute () method, while the STL-style functors are - * invoked via an operator() () method. - * Non-templatized classes for implementing the GoF Command Pattern, - * also known as functors or function objects. - * - * @author Chris Gill - * @author Based on Command Pattern implementations originally done by - * @author Carlos O'Ryan - * @author Douglas C. Schmidt - * @author Sergio Flores-Gaitan - * @author and on STL-style functor implementations originally done by - * @author Irfan Pyarali - */ -//========================================================================== - - -#ifndef ACE_FUNCTOR_H -#define ACE_FUNCTOR_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include /**/ "ace/ACE_export.h" -#include "ace/Basic_Types.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -////////////////////////////////////////////////////////////// -// GOF Command Pattern Classes and Template Specializations // -////////////////////////////////////////////////////////////// - -/** - * @class ACE_Command_Base - * - * @brief Defines an abstract class that allows us to invoke commands - * without knowing anything about the implementation. - * - * This class declares an interface to execute a command - * independent of the effect of the command, or the objects used - * to implement it. - */ -class ACE_Export ACE_Command_Base -{ -public: - /// Default constructor. - ACE_Command_Base (void); - - /// Virtual destructor. - virtual ~ACE_Command_Base (void); - - /** - * Invokes the method encapsulated by the command, passing along the - * passed argument (if any). Users of classes derived from this - * class must ensure that the resulting invocation can tolerate a - * null void pointer being passed, or otherwise ensure that this - * will never occur. - */ - virtual int execute (void *arg = 0) = 0; -}; - -/** - * @class ACE_Noop_Command - * - * Implements a ACE_Command_Base with an empty execute() body. - */ - -class ACE_Export ACE_Noop_Command - : public ACE_Command_Base -{ -public: - /// Constructor - ACE_Noop_Command(); - - /// Implement the empty execute() member function - virtual int execute(void*); -}; - -//////////////////////////////////////////////////////////// -// STL-style Functor Classes and Template Specializations // -//////////////////////////////////////////////////////////// - -// Forward declaration since we are going to specialize that template -// here. The template itself requires this file so every user of the -// template should also see the specialization. -template class ACE_Hash; -template class ACE_Equal_To; -template class ACE_Less_Than; - -/** - * @brief Function object for hashing a char - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (char t) const; -}; - -/** - * @brief Function object for hashing a signed char - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (signed char t) const; -}; - -/** - * @brief Function object for hashing an unsigned char - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (unsigned char t) const; -}; - -/** - * @brief Function object for hashing a short number - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (short t) const; -}; - -/** - * @brief Function object for hashing an unsigned short number - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (unsigned short t) const; -}; - -/** - * @brief Function object for hashing an int number - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (int t) const; -}; - -/** - * @brief Function object for hashing an unsigned int number - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (unsigned int t) const; -}; - -/** - * @brief Function object for hashing a long number - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (long t) const; -}; - -/** - * @brief Function object for hashing an unsigned long number - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (unsigned long t) const; -}; - -#if (ACE_SIZEOF_LONG == 8) -/** - * @brief Function object for hashing a long long number - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (long long t) const; -}; -#endif /* ACE_SIZEOF_LONG == 8 */ - -#if (ACE_SIZEOF_LONG == 8) -/** - * @brief Function object for hashing an unsigned long long number - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (unsigned long long t) const; -}; -#endif /* ACE_SIZEOF_LONG == 8 */ - -#if (ACE_SIZEOF_LONG < 8) -/** - * @brief Function object for hashing a signed 64-bit number - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (ACE_INT64 t) const; -}; -#endif /* ACE_SIZEOF_LONG < 8 */ - -#if (ACE_SIZEOF_LONG < 8) -/** - * @brief Function object for hashing an unsigned 64-bit number - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (const ACE_UINT64 &t) const; -}; -#endif /* ACE_SIZEOF_LONG < 8 */ - -/** - * @brief Function object for hashing a const string - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Calls ACE::hash_pjw - unsigned long operator () (const char *t) const; -}; - -/** - * @brief Function object for hashing a string - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Calls ACE::hash_pjw - unsigned long operator () (const char *t) const; -}; - -/** - * @brief Function object for hashing a void */ -template<> -class ACE_Export ACE_Hash -{ -public: - unsigned long operator () (const void *) const; -}; - -/** - * @brief Function object for determining whether two const strings are equal. - */ -template<> -class ACE_Export ACE_Equal_To -{ -public: - /// Simply calls ACE_OS::strcmp - int operator () (const char *lhs, - const char *rhs) const; -}; - -/** - * @brief Function object for determining whether two non-const - * strings are equal. - */ -template<> -class ACE_Export ACE_Equal_To -{ -public: - /// Simply calls ACE_OS::strcmp - int operator () (const char *lhs, - const char *rhs) const; -}; - -/** - * @brief Function object for determining whether two unsigned - * 16 bit ints are equal. - */ -template<> -class ACE_Export ACE_Equal_To -{ -public: - /// Simply calls built-in operators - int operator () (const ACE_UINT16 lhs, - const ACE_UINT16 rhs) const; -}; - -/** - * @brief Function object for determining whether two - * 16 bit ints are equal. - */ -template<> -class ACE_Export ACE_Equal_To -{ -public: - /// Simply calls built-in operators - int operator () (const ACE_INT16 lhs, - const ACE_INT16 rhs) const; -}; - -/** - * @brief Function object for determining whether two unsigned - * 32 bit ints are equal. - */ -template<> -class ACE_Export ACE_Equal_To -{ -public: - /// Simply calls built-in operators - int operator () (const ACE_UINT32 lhs, - const ACE_UINT32 rhs) const; -}; - -/** - * @brief Function object for determining whether two - * 32 bit ints are equal. - */ -template<> -class ACE_Export ACE_Equal_To -{ -public: - /// Simply calls built-in operators - int operator () (const ACE_INT32 lhs, - const ACE_INT32 rhs) const; -}; - -/** - * @brief Function object for determining whether two unsigned - * 64 bit ints are equal. - */ -template<> -class ACE_Export ACE_Equal_To -{ -public: - /// Simply calls built-in operators - int operator () (const ACE_UINT64 lhs, - const ACE_UINT64 rhs) const; -}; - -/** - * @brief Function object for determining whether the first const string - * is less than the second const string. - */ -template<> -class ACE_Export ACE_Less_Than -{ -public: - /// Simply calls ACE_OS::strcmp - int operator () (const char *lhs, - const char *rhs) const; -}; - -/** - * @brief Function object for determining whether the first string - * is less than the second string. - */ -template<> -class ACE_Export ACE_Less_Than -{ -public: - /// Simply calls ACE_OS::strcmp - int operator () (const char *lhs, - const char *rhs) const; -}; - -#if defined (ACE_HAS_WCHAR) - -# if ! defined (ACE_LACKS_NATIVE_WCHAR_T) -/** - * @brief Function object for hashing a wchar_t - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Simply returns t - unsigned long operator () (wchar_t t) const; -}; -# endif /* ACE_LACKS_NATIVE_WCHAR_T */ -/** - * @brief Function object for hashing a const string - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Calls ACE::hash_pjw - unsigned long operator () (const wchar_t *t) const; -}; - -/** - * @brief Function object for hashing a string - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Calls ACE::hash_pjw - unsigned long operator () (const wchar_t *t) const; -}; - -/** - * @brief Function object for determining whether two const strings are equal. - */ -template<> -class ACE_Export ACE_Equal_To -{ -public: - /// Simply calls ACE_OS::strcmp - int operator () (const wchar_t *lhs, - const wchar_t *rhs) const; -}; - -/** - * @brief Function object for determining whether two non-const - * strings are equal. - */ -template<> -class ACE_Export ACE_Equal_To -{ -public: - /// Simply calls ACE_OS::strcmp - int operator () (const wchar_t *lhs, - const wchar_t *rhs) const; -}; - -/** - * @brief Function object for determining whether the first const string - * is less than the second const string. - */ -template<> -class ACE_Export ACE_Less_Than -{ -public: - /// Simply calls ACE_OS::strcmp - int operator () (const wchar_t *lhs, - const wchar_t *rhs) const; -}; - -/** - * @brief Function object for determining whether the first string - * is less than the second string. - */ -template<> -class ACE_Export ACE_Less_Than -{ -public: - /// Simply calls ACE_OS::strcmp - int operator () (const wchar_t *lhs, - const wchar_t *rhs) const; -}; - -#endif // ACE_HAS_WCHAR - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Functor.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_FUNCTOR_H */ diff --git a/deps/acelite/ace/Functor.inl b/deps/acelite/ace/Functor.inl deleted file mode 100644 index d50490d9f..000000000 --- a/deps/acelite/ace/Functor.inl +++ /dev/null @@ -1,261 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Functor.inl - * - * Inlinable method definitions for non-templatized classes - * and template specializations implementing the GOF Command Pattern, - * and STL-style functors. - * - * @author Chris Gill - * - * Based on Command Pattern implementations originally done by - * - * Carlos O'Ryan - * Douglas C. Schmidt - * Sergio Flores-Gaitan - * - * and on STL-style functor implementations originally done by - * Irfan Pyarali - */ -//============================================================================= - - -#include "ace/ACE.h" -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -////////////////////////////////////////////////////////////// -// GOF Command Pattern Classes and Template Specializations // -////////////////////////////////////////////////////////////// - -// Default constructor. - -ACE_INLINE -ACE_Command_Base::ACE_Command_Base (void) -{ -} - -//////////////////////////////////////////////////////////// -// STL-style Functor Classes and Template Specializations // -//////////////////////////////////////////////////////////// - -ACE_INLINE unsigned long -ACE_Hash::operator () (char t) const -{ - return t; -} - -#if defined (ACE_HAS_WCHAR) && ! defined (ACE_LACKS_NATIVE_WCHAR_T) -ACE_INLINE unsigned long -ACE_Hash::operator () (wchar_t t) const -{ - return t; -} -#endif /* ACE_HAS_WCHAR && ! ACE_LACKS_NATIVE_WCHAR_T */ - -ACE_INLINE unsigned long -ACE_Hash::operator () (signed char t) const -{ - return t; -} - -ACE_INLINE unsigned long -ACE_Hash::operator () (unsigned char t) const -{ - return t; -} - -ACE_INLINE unsigned long -ACE_Hash::operator () (short t) const -{ - return static_cast (t); -} - -ACE_INLINE unsigned long -ACE_Hash::operator () (unsigned short t) const -{ - return static_cast (t); -} - -ACE_INLINE unsigned long -ACE_Hash::operator () (int t) const -{ - return static_cast (t); -} - -ACE_INLINE unsigned long -ACE_Hash::operator () (unsigned int t) const -{ - return static_cast (t); -} - -ACE_INLINE unsigned long -ACE_Hash::operator () (long t) const -{ - return static_cast (t); -} - -ACE_INLINE unsigned long -ACE_Hash::operator () (unsigned long t) const -{ - return t; -} - -#if (ACE_SIZEOF_LONG == 8) -ACE_INLINE unsigned long -ACE_Hash::operator () (long long t) const -{ - return static_cast (t); -} -#endif /* ACE_SIZEOF_LONG == 8 */ - -#if (ACE_SIZEOF_LONG == 8) -ACE_INLINE unsigned long -ACE_Hash::operator () (unsigned long long t) const -{ - return static_cast (t); -} -#endif /* ACE_SIZEOF_LONG == 8 */ - -// This #if needs to match the one in Functor.h -#if (ACE_SIZEOF_LONG < 8) -ACE_INLINE unsigned long -ACE_Hash::operator () (ACE_INT64 t) const -{ - return static_cast (t); -} -#endif /* ACE_SIZEOF_LONG < 8 */ - -#if (ACE_SIZEOF_LONG < 8) -ACE_INLINE unsigned long -ACE_Hash::operator () (const ACE_UINT64 &t) const -{ -#if (ACE_SIZEOF_LONG == 4) - return ACE_U64_TO_U32 (t); -#else - return static_cast (t); -#endif /* ACE_SIZEOF_LONG */ -} -#endif /* ACE_SIZEOF_LONG < 8 */ - -ACE_INLINE unsigned long -ACE_Hash::operator () (const char *t) const -{ - return ACE::hash_pjw (t); -} - -ACE_INLINE unsigned long -ACE_Hash::operator () (const char *t) const -{ - return ACE::hash_pjw (t); -} - -ACE_INLINE unsigned long -ACE_Hash::operator () (const void *t) const -{ - return static_cast (reinterpret_cast (t)); -} - -/***********************************************************************/ -ACE_INLINE int -ACE_Equal_To::operator () (const char *lhs, const char *rhs) const -{ - return !ACE_OS::strcmp (lhs, rhs); -} - -ACE_INLINE int -ACE_Equal_To::operator () (const char *lhs, const char *rhs) const -{ - return !ACE_OS::strcmp (lhs, rhs); -} - -ACE_INLINE int -ACE_Equal_To::operator () (const ACE_UINT16 lhs, const ACE_UINT16 rhs) const -{ - return (lhs == rhs); -} - -ACE_INLINE int -ACE_Equal_To::operator () (const ACE_INT16 lhs, const ACE_INT16 rhs) const -{ - return (lhs == rhs); -} - -ACE_INLINE int -ACE_Equal_To::operator () (const ACE_UINT32 lhs, const ACE_UINT32 rhs) const -{ - return (lhs == rhs); -} - -ACE_INLINE int -ACE_Equal_To::operator () (const ACE_INT32 lhs, const ACE_INT32 rhs) const -{ - return (lhs == rhs); -} - -ACE_INLINE int -ACE_Equal_To::operator () (const ACE_UINT64 lhs, const ACE_UINT64 rhs) const -{ - return (lhs == rhs); -} - -/****************************************************************************/ -ACE_INLINE int -ACE_Less_Than::operator () (const char *lhs, const char *rhs) const -{ - return (ACE_OS::strcmp (lhs, rhs) < 0) ? 1 : 0; -} - -ACE_INLINE int -ACE_Less_Than::operator () (const char *lhs, const char *rhs) const -{ - return (ACE_OS::strcmp (lhs, rhs) < 0) ? 1 : 0; -} - - -#if defined (ACE_HAS_WCHAR) - -ACE_INLINE unsigned long -ACE_Hash::operator () (const wchar_t *t) const -{ - return ACE::hash_pjw (t); -} - -ACE_INLINE unsigned long -ACE_Hash::operator () (const wchar_t *t) const -{ - return ACE::hash_pjw (t); -} - -ACE_INLINE int -ACE_Equal_To::operator () (const wchar_t *lhs, - const wchar_t *rhs) const -{ - return !ACE_OS::strcmp (lhs, rhs); -} - -ACE_INLINE int -ACE_Equal_To::operator () (const wchar_t *lhs, - const wchar_t *rhs) const -{ - return !ACE_OS::strcmp (lhs, rhs); -} - -ACE_INLINE int -ACE_Less_Than::operator () (const wchar_t *lhs, const wchar_t *rhs) const -{ - return (ACE_OS::strcmp (lhs, rhs) < 0) ? 1 : 0; -} - -ACE_INLINE int -ACE_Less_Than::operator () (const wchar_t *lhs, const wchar_t *rhs) const -{ - return (ACE_OS::strcmp (lhs, rhs) < 0) ? 1 : 0; -} - -#endif // ACE_HAS_WCHAR - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Functor_String.cpp b/deps/acelite/ace/Functor_String.cpp deleted file mode 100644 index e12934fca..000000000 --- a/deps/acelite/ace/Functor_String.cpp +++ /dev/null @@ -1,7 +0,0 @@ -#include "ace/Functor_String.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Functor_String.inl" -#endif /* __ACE_INLINE__ */ - - diff --git a/deps/acelite/ace/Functor_String.h b/deps/acelite/ace/Functor_String.h deleted file mode 100644 index c04cc01c5..000000000 --- a/deps/acelite/ace/Functor_String.h +++ /dev/null @@ -1,166 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Functor_String.h - * - * Class template specializations for ACE_*String types implementing - * function objects that are used in various places in ATC. They - * could be placed in Functor.h. But we don't want to couple string - * types to the rest of ACE+TAO. Hence they are placed in a separate - * file. - */ -//========================================================================== -#ifndef ACE_FUNCTOR_STRING_H -#define ACE_FUNCTOR_STRING_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include /**/ "ace/ACE_export.h" -#include "ace/SStringfwd.h" -#include - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -//////////////////////////////////////////////////////////// -// STL-style Functor Classes and Template Specializations // -//////////////////////////////////////////////////////////// - -// Forward declaration since we are going to specialize that template -// here. The template itself requires this file so every user of the -// template should also see the specialization. -template class ACE_Hash; -template class ACE_Equal_To; -template class ACE_Less_Than; - -/** - * @brief Function object for determining whether two ACE_CStrings are - * equal. - */ -template<> -class ACE_Export ACE_Equal_To -{ -public: - int operator () (const ACE_CString &lhs, - const ACE_CString &rhs) const; -}; - - -/** - * @brief Function object for hashing a ACE_CString - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Calls ACE::hash_pjw - unsigned long operator () (const ACE_CString &lhs) const; -}; - - -/** - * @brief Function object for determining whether the first const string - * is less than the second const string. - */ -template<> -class ACE_Export ACE_Less_Than -{ -public: - /// Simply calls ACE_OS::strcmp - int operator () (const ACE_CString &lhs, - const ACE_CString &rhs) const; -}; - -/** - * @brief Function object for determining whether two std::strings are - * equal. - */ -template<> -class ACE_Export ACE_Equal_To -{ -public: - int operator () (const std::string &lhs, - const std::string &rhs) const; -}; - - -/** - * @brief Function object for hashing a std::string - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Calls ACE::hash_pjw - unsigned long operator () (const std::string &lhs) const; -}; - - -/** - * @brief Function object for determining whether the first const string - * is less than the second const string. - */ -template<> -class ACE_Export ACE_Less_Than -{ -public: - /// Simply calls std::string::compare - int operator () (const std::string &lhs, - const std::string &rhs) const; -}; - - -#if defined (ACE_USES_WCHAR) - -/** - * @brief Function object for determining whether two ACE_WStrings are - * equal. - */ -template<> -class ACE_Export ACE_Equal_To -{ -public: - int operator () (const ACE_WString &lhs, - const ACE_WString &rhs) const; -}; - - -/** - * @brief Function object for hashing a ACE_WString - */ -template<> -class ACE_Export ACE_Hash -{ -public: - /// Calls ACE::hash_pjw - unsigned long operator () (const ACE_WString &lhs) const; -}; - -/** - * @brief Function object for determining whether the first const wstring - * is less than the second const wstring. - */ -template<> -class ACE_Export ACE_Less_Than -{ -public: - /// Simply calls ACE_OS::strcmp - int operator () (const ACE_WString &lhs, - const ACE_WString &rhs) const; -}; - -#endif /*ACE_USES_WCHAR*/ - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Functor_String.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /*ACE_FUNCTOR_STRING_H*/ diff --git a/deps/acelite/ace/Functor_String.inl b/deps/acelite/ace/Functor_String.inl deleted file mode 100644 index d6f427f4a..000000000 --- a/deps/acelite/ace/Functor_String.inl +++ /dev/null @@ -1,73 +0,0 @@ -// -*- C++ -*- -#include "ace/ACE.h" -#include "ace/String_Base.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE unsigned long -ACE_Hash::operator () (const ACE_CString &t) const -{ - return t.hash (); -} - - -ACE_INLINE int -ACE_Equal_To::operator () (const ACE_CString &lhs, - const ACE_CString &rhs) const -{ - return lhs == rhs; -} - -ACE_INLINE int -ACE_Less_Than::operator () (const ACE_CString &lhs, - const ACE_CString &rhs) const -{ - return (lhs < rhs); -} - -ACE_INLINE unsigned long -ACE_Hash::operator () (const std::string &t) const -{ - return ACE::hash_pjw (t.c_str (), t.length ()); -} - - -ACE_INLINE int -ACE_Equal_To::operator () (const std::string &lhs, - const std::string &rhs) const -{ - return lhs == rhs; -} - -ACE_INLINE int -ACE_Less_Than::operator () (const std::string &lhs, - const std::string &rhs) const -{ - return (lhs < rhs); -} - -#if defined (ACE_USES_WCHAR) -ACE_INLINE unsigned long -ACE_Hash::operator () (const ACE_WString &t) const -{ - return t.hash (); -} - - -ACE_INLINE int -ACE_Equal_To::operator () (const ACE_WString &lhs, - const ACE_WString &rhs) const -{ - return lhs == rhs; -} - -ACE_INLINE int -ACE_Less_Than::operator () (const ACE_WString &lhs, - const ACE_WString &rhs) const -{ - return (lhs < rhs); -} - -#endif /*ACE_USES_WCHAR*/ - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Functor_T.cpp b/deps/acelite/ace/Functor_T.cpp deleted file mode 100644 index 9b99c5029..000000000 --- a/deps/acelite/ace/Functor_T.cpp +++ /dev/null @@ -1,51 +0,0 @@ -#ifndef ACE_FUNCTOR_T_CPP -#define ACE_FUNCTOR_T_CPP - -#include "ace/Functor_T.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (__ACE_INLINE__) -#include "ace/Functor_T.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Command_Callback) - -/////////////////////////////////// -// GOF Command Pattern Templates // -/////////////////////////////////// - -// Constructor. - -template -ACE_Command_Callback::ACE_Command_Callback (RECEIVER &recvr, - ACTION action) - : receiver_ (recvr), - action_ (action) -{ -} - -template -ACE_Command_Callback::~ACE_Command_Callback (void) -{ -} - -// Invokes an operation. - -template int -ACE_Command_Callback::execute (void *arg) -{ - return (receiver_.*action_) (arg); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_FUNCTOR_T_CPP */ diff --git a/deps/acelite/ace/Functor_T.h b/deps/acelite/ace/Functor_T.h deleted file mode 100644 index f89b683d5..000000000 --- a/deps/acelite/ace/Functor_T.h +++ /dev/null @@ -1,193 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Functor_T.h - * - * Templatized classes for implementing function objects that are - * used in various places in ACE. There are currently two major - * categories of function objects in ACE: GOF Command Pattern - * objects, and STL-style functors for comparison of container - * elements. The command objects are invoked via an - * method, while the STL-style functors are invoked via an - * method. - * - * @author Chris Gill - * @author Based on Command Pattern implementations originally done by - * @author Carlos O'Ryan - * @author Douglas C. Schmidt - * @author Sergio Flores-Gaitan - * @author and on STL-style functor implementations originally done by - * @author Irfan Pyarali - */ -//============================================================================= - - -#ifndef ACE_FUNCTOR_T_H -#define ACE_FUNCTOR_T_H -#include /**/ "ace/pre.h" - -#include "ace/Functor.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Functor_String.h" -#include "ace/Truncate.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/////////////////////////////////// -// GOF Command Pattern Templates // -/////////////////////////////////// - -/** - * @class ACE_Command_Callback - * - * @brief - * Defines a class template that allows us to invoke a GOF - * command style callback to an object without knowing anything - * about the object except its type. - * - * This class declares an interface to execute operations, - * binding a RECEIVER object with an ACTION. The RECEIVER knows - * how to implement the operation. A class can invoke operations - * without knowing anything about it, or how it was implemented. - */ -template -class ACE_Command_Callback : public ACE_Command_Base -{ -public: - /// Constructor: sets the @c receiver_ of the Command to @a recvr, and the - /// @c action_ of the Command to @a action. - ACE_Command_Callback (RECEIVER &recvr, ACTION action); - - /// Virtual destructor. - virtual ~ACE_Command_Callback (void); - - /// Invokes the method @c action_ from the object @c receiver_. - virtual int execute (void *arg = 0); - - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Object where the method resides. - RECEIVER &receiver_; - - /// Method that is going to be invoked. - ACTION action_; -}; - -/** - * @class ACE_Member_Function_Command - * - * @brief Defines a class template that allows us to invoke a member - * function using the GoF command style callback. - */ -template -class ACE_Member_Function_Command : public ACE_Command_Base -{ -public: - typedef void (RECEIVER::*PTMF)(void); - - /// Con Constructor: sets the of the Command to @a recvr, and the - /// of the Command to . - ACE_Member_Function_Command (RECEIVER &recvr, PTMF ptmf); - - /// Virtual destructor. - virtual ~ACE_Member_Function_Command (void); - - /// Invokes the method from the object . The - /// parameter is ignored - virtual int execute (void *); - -private: - /// Object where the method resides. - RECEIVER &receiver_; - - /// Method that is going to be invoked. - PTMF ptmf_; -}; - -///////////////////////////////// -// STL-style Functor Templates // -///////////////////////////////// - -/** - * @class ACE_Hash - * - * @brief Function object for hashing - */ -template -class ACE_Hash -{ -public: - /// Simply calls t.hash () - unsigned long operator () (const TYPE &t) const; -}; - -/** - * @class ACE_Pointer_Hash - * - * @brief - * Function object for hashing pointers - */ -template -class ACE_Pointer_Hash -{ -public: - /// Simply returns t. - unsigned long operator () (TYPE t) const; -}; - -/** - * @class ACE_Equal_To - * - * @brief - * Function object for comparing two objects of - * the given type for equality. - */ -template -class ACE_Equal_To -{ -public: - /// Simply calls operator== - bool operator () (const TYPE &lhs, - const TYPE &rhs) const; -}; - -/** - * @class ACE_Less_Than - * - * @brief - * Function object for determining whether the first object of - * the given type is less than the second object of the same - * type. - */ -template -class ACE_Less_Than -{ -public: - /// Simply calls operator< - bool operator () (const TYPE &lhs, - const TYPE &rhs) const; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Functor_T.inl" -#endif /* __ACE_INLINE__ */ - - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Functor_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Functor_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_FUNCTOR_T_H */ diff --git a/deps/acelite/ace/Functor_T.inl b/deps/acelite/ace/Functor_T.inl deleted file mode 100644 index 415a0090b..000000000 --- a/deps/acelite/ace/Functor_T.inl +++ /dev/null @@ -1,60 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE -ACE_Member_Function_Command:: -ACE_Member_Function_Command (RECEIVER &recvr, PTMF ptmf) - : receiver_(recvr) - , ptmf_(ptmf) -{ -} - -template ACE_INLINE -ACE_Member_Function_Command:: -~ACE_Member_Function_Command (void) -{ -} - -template ACE_INLINE int -ACE_Member_Function_Command::execute (void *) -{ - (this->receiver_.*ptmf_)(); - return 0; -} - -template ACE_INLINE unsigned long -ACE_Hash::operator () (const TYPE &t) const -{ - return t.hash (); -} - -template ACE_INLINE unsigned long -ACE_Pointer_Hash::operator () (TYPE t) const -{ -#if defined (ACE_WIN64) - // The cast below is legit... we only want a hash, and need not convert - // the hash back to a pointer. -# pragma warning(push) -# pragma warning(disable : 4311) /* Truncate pointer to unsigned long */ -#endif /* ACE_WIN64 */ - return ACE_Utils::truncate_cast ((intptr_t)t); -#if defined (ACE_WIN64) -# pragma warning(pop) -#endif /* ACE_WIN64 */ -} - -template ACE_INLINE bool -ACE_Equal_To::operator () (const TYPE &lhs, - const TYPE &rhs) const -{ - return lhs == rhs; -} - -template ACE_INLINE bool -ACE_Less_Than::operator () (const TYPE &lhs, - const TYPE &rhs) const -{ - return lhs < rhs; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Future.cpp b/deps/acelite/ace/Future.cpp deleted file mode 100644 index c2ec6adfc..000000000 --- a/deps/acelite/ace/Future.cpp +++ /dev/null @@ -1,438 +0,0 @@ -#ifndef ACE_FUTURE_CPP -#define ACE_FUTURE_CPP - -#include "ace/Future.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_THREADS) - -# include "ace/Guard_T.h" -# include "ace/Recursive_Thread_Mutex.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Future_Holder) -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Future_Observer) -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Future_Rep) -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Future) - -template -ACE_Future_Holder::ACE_Future_Holder (void) -{ -} - -template -ACE_Future_Holder::ACE_Future_Holder (const ACE_Future &item) - : item_ (item) -{ -} - -template -ACE_Future_Holder::~ACE_Future_Holder (void) -{ -} - -template -ACE_Future_Observer::ACE_Future_Observer (void) -{ -} - -template -ACE_Future_Observer::~ACE_Future_Observer (void) -{ -} - -// Dump the state of an object. - -template void -ACE_Future_Rep::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, - "ref_count_ = %d\n", - (int) this->ref_count_)); - ACELIB_DEBUG ((LM_INFO,"value_:\n")); - if (this->value_) - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT (" (NON-NULL)\n"))); - else - //FUZZ: disable check_for_NULL - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT (" (NULL)\n"))); - //FUZZ: enable check_for_NULL - - ACELIB_DEBUG ((LM_INFO,"value_ready_:\n")); - this->value_ready_.dump (); - ACELIB_DEBUG ((LM_INFO,"value_ready_mutex_:\n")); - this->value_ready_mutex_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -template ACE_Future_Rep * -ACE_Future_Rep::internal_create (void) -{ - ACE_Future_Rep *temp = 0; - ACE_NEW_RETURN (temp, - ACE_Future_Rep (), - 0); - return temp; -} - -template ACE_Future_Rep * -ACE_Future_Rep::create (void) -{ - // Yes set ref count to zero. - ACE_Future_Rep *temp = internal_create (); -#if defined (ACE_NEW_THROWS_EXCEPTIONS) - if (temp == 0) - ACE_throw_bad_alloc; -#else - ACE_ASSERT (temp != 0); -#endif /* ACE_NEW_THROWS_EXCEPTIONS */ - return temp; - } - - -template ACE_Future_Rep * -ACE_Future_Rep::attach (ACE_Future_Rep*& rep) -{ - ACE_ASSERT (rep != 0); - // Use value_ready_mutex_ for both condition and ref count management - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, r_mon, rep->value_ready_mutex_, 0); - ++rep->ref_count_; - return rep; -} - -template void -ACE_Future_Rep::detach (ACE_Future_Rep*& rep) -{ - ACE_ASSERT (rep != 0); - // Use value_ready_mutex_ for both condition and ref count management - ACE_GUARD (ACE_SYNCH_RECURSIVE_MUTEX, r_mon, rep->value_ready_mutex_); - - if (rep->ref_count_-- == 0) - { - ACE_MT (r_mon.release ()); - // We do not need the lock when deleting the representation. - // There should be no side effects from deleting rep and we don - // not want to release a deleted mutex. - delete rep; - } -} - -template void -ACE_Future_Rep::assign (ACE_Future_Rep*& rep, ACE_Future_Rep* new_rep) -{ - ACE_ASSERT (rep != 0); - ACE_ASSERT (new_rep != 0); - // Use value_ready_mutex_ for both condition and ref count management - ACE_GUARD (ACE_SYNCH_RECURSIVE_MUTEX, r_mon, rep->value_ready_mutex_); - - ACE_Future_Rep* old = rep; - rep = new_rep; - - // detached old last for exception safety - if (old->ref_count_-- == 0) - { - ACE_MT (r_mon.release ()); - // We do not need the lock when deleting the representation. - // There should be no side effects from deleting rep and we don - // not want to release a deleted mutex. - delete old; - } -} - -template -ACE_Future_Rep::ACE_Future_Rep (void) - : value_ (0), - ref_count_ (0), - value_ready_ (value_ready_mutex_) -{ -} - -template -ACE_Future_Rep::~ACE_Future_Rep (void) -{ - delete this->value_; -} - -template int -ACE_Future_Rep::ready (void) const -{ - return this->value_ != 0; -} - -template int -ACE_Future_Rep::set (const T &r, - ACE_Future &caller) -{ - // If the value is already produced, ignore it... - if (this->value_ == 0) - { - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, - ace_mon, - this->value_ready_mutex_, - -1); - // Otherwise, create a new result value. Note the use of the - // Double-checked locking pattern to avoid multiple allocations. - - if (this->value_ == 0) // Still no value, so proceed - { - ACE_NEW_RETURN (this->value_, - T (r), - -1); - - // Remove and notify all subscribed observers. - typename OBSERVER_COLLECTION::iterator iterator = - this->observer_collection_.begin (); - - typename OBSERVER_COLLECTION::iterator end = - this->observer_collection_.end (); - - while (iterator != end) - { - OBSERVER *observer = *iterator++; - if (observer) - { - observer->update (caller); - } - } - - // Signal all the waiting threads. - return this->value_ready_.broadcast (); - } - // Destructor releases the lock. - } - return 0; -} - -template int -ACE_Future_Rep::get (T &value, - ACE_Time_Value *tv) const -{ - // If the value is already produced, return it. - if (this->value_ == 0) - { - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, - this->value_ready_mutex_, - -1); - // If the value is not yet defined we must block until the - // producer writes to it. - - while (this->value_ == 0) - // Perform a timed wait. - if (this->value_ready_.wait (tv) == -1) - return -1; - - // Destructor releases the lock. - } - - value = *this->value_; - return 0; -} - -template int -ACE_Future_Rep::attach (ACE_Future_Observer *observer, - ACE_Future &caller) -{ - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->value_ready_mutex_, -1); - - // Otherwise, create a new result value. Note the use of the - // Double-checked locking pattern to avoid corrupting the list. - - int result = 1; - - // If the value is already produced, then notify observer - if (this->value_ == 0) - result = this->observer_collection_.insert (observer); - else - observer->update (caller); - - return result; -} - -template int -ACE_Future_Rep::detach (ACE_Future_Observer *observer) -{ - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->value_ready_mutex_, -1); - - // Remove all occurrences of the specified observer from this - // objects hash map. - return this->observer_collection_.remove (observer); -} - -template -ACE_Future_Rep::operator T () -{ - // If the value is already produced, return it. - if (this->value_ == 0) - { - // Constructor of ace_mon acquires the mutex. - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->value_ready_mutex_, 0); - - // If the value is not yet defined we must block until the - // producer writes to it. - - // Wait ``forever.'' - - while (this->value_ == 0) - if (this->value_ready_.wait () == -1) - // What to do in this case since we've got to indicate - // failure somehow? Exceptions would be nice, but they're - // not portable... - return 0; - - // Destructor releases the mutex - } - - return *this->value_; -} - -template -ACE_Future::ACE_Future (void) - : future_rep_ (FUTURE_REP::create ()) -{ -} - -template -ACE_Future::ACE_Future (const ACE_Future &r) - : future_rep_ (FUTURE_REP::attach (((ACE_Future &) r).future_rep_)) -{ -} - -template -ACE_Future::ACE_Future (const T &r) - : future_rep_ (FUTURE_REP::create ()) -{ - this->future_rep_->set (r, *this); -} - -template -ACE_Future::~ACE_Future (void) -{ - FUTURE_REP::detach (future_rep_); -} - -template bool -ACE_Future::operator== (const ACE_Future &r) const -{ - return r.future_rep_ == this->future_rep_; -} - -template bool -ACE_Future::operator!= (const ACE_Future &r) const -{ - return r.future_rep_ != this->future_rep_; -} - -template int -ACE_Future::cancel (const T &r) -{ - this->cancel (); - return this->future_rep_->set (r, *this); -} - -template int -ACE_Future::cancel (void) -{ - // If this ACE_Future is already attached to a ACE_Future_Rep, - // detach it (maybe delete the ACE_Future_Rep). - FUTURE_REP::assign (this->future_rep_, - FUTURE_REP::create ()); - return 0; -} - -template int -ACE_Future::set (const T &r) -{ - // Give the pointer to the result to the ACE_Future_Rep. - return this->future_rep_->set (r, *this); -} - -template int -ACE_Future::ready (void) const -{ - // We're ready if the ACE_Future_rep is ready... - return this->future_rep_->ready (); -} - -template int -ACE_Future::get (T &value, - ACE_Time_Value *tv) const -{ - // We return the ACE_Future_rep. - return this->future_rep_->get (value, tv); -} - -template int -ACE_Future::attach (ACE_Future_Observer *observer) -{ - return this->future_rep_->attach (observer, *this); -} - -template int -ACE_Future::detach (ACE_Future_Observer *observer) -{ - return this->future_rep_->detach (observer); -} - -template -ACE_Future::operator T () -{ - // note that this will fail (and COREDUMP!) - // if future_rep_ == 0 ! - // - // but... - // this is impossible unless somebody is so stupid to - // try something like this: - // - // Future futT; - // T t; - // t = futT; - - // perform type conversion on Future_Rep. - return *future_rep_; -} - -template void -ACE_Future::operator = (const ACE_Future &rhs) -{ - // assignment: - // - // bind to the same as . - - // This will work if &r == this, by first increasing the ref count - ACE_Future &r = (ACE_Future &) rhs; - FUTURE_REP::assign (this->future_rep_, - FUTURE_REP::attach (r.future_rep_)); -} - -template void -ACE_Future::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACELIB_DEBUG ((LM_DEBUG, - ACE_BEGIN_DUMP, this)); - - if (this->future_rep_) - this->future_rep_->dump (); - - ACELIB_DEBUG ((LM_DEBUG, - ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -template ACE_Future_Rep * -ACE_Future::get_rep () -{ - return this->future_rep_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_THREADS */ - -#endif /* ACE_FUTURE_CPP */ diff --git a/deps/acelite/ace/Future.h b/deps/acelite/ace/Future.h deleted file mode 100644 index dcaf1eb7d..000000000 --- a/deps/acelite/ace/Future.h +++ /dev/null @@ -1,381 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Future.h - * - * @author Andres Kruse - * @author Douglas C. Schmidt - * @author Per Andersson and - * @author John Tucker - */ -//============================================================================= - -#ifndef ACE_FUTURE_H -#define ACE_FUTURE_H - -#include /**/ "ace/pre.h" - -#include "ace/Unbounded_Set.h" -#include "ace/Strategies_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_THREADS) - -#include "ace/Synch_Traits.h" -#include "ace/Recursive_Thread_Mutex.h" -#include "ace/Condition_Recursive_Thread_Mutex.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward decl. -template class ACE_Future_Holder; -template class ACE_Future_Observer; -template class ACE_Future_Rep; -template class ACE_Future; - -/** - * @class ACE_Future_Holder - * - * @brief Implementation of object that holds an ACE_Future. - */ -template -class ACE_Future_Holder -{ -public: - ACE_Future_Holder (const ACE_Future &future); - ~ACE_Future_Holder (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - ACE_Future item_; - -protected: - ACE_Future_Holder (void); -}; - -/** - * @class ACE_Future_Observer - * - * @brief ACE_Future_Observer - * - * An ACE_Future_Observer object implements an object that is - * subscribed with an ACE_Future object so that it may be notified - * when the value of the ACE_Future object is written to by a writer - * thread. It uses the Observer pattern. - */ -template -class ACE_Future_Observer -{ -public: - /// Destructor - virtual ~ACE_Future_Observer (void); - - /// Called by the ACE_Future in which we are subscribed to when - /// its value is written to. - virtual void update (const ACE_Future &future) = 0; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Constructor - ACE_Future_Observer (void); -}; - -/** - * @class ACE_Future_Rep - * - * @internal - * - * @brief ACE_Future_Rep - * - * An ACE_Future_Rep object encapsulates a pointer to an object - * of class T which is the result of an asynchronous method - * invocation. It is pointed to by ACE_Future object[s] and - * only accessible through them. - */ -template -class ACE_Future_Rep -{ -private: - friend class ACE_Future; - - /** - * Set the result value. The specified @a caller represents the - * future that invoked this method, which is used to notify - * the list of future observers. Returns 0 for success, -1 on error. - * This function only has an effect the first time it is called for - * the object. Subsequent calls return 0 (success) but have no effect. - */ - int set (const T &r, - ACE_Future &caller); - - /// Wait up to @a tv time to get the @a value. Note that @a tv must be - /// specified in absolute time rather than relative time. - int get (T &value, - ACE_Time_Value *tv) const; - - /** - * Attaches the specified observer to a subject (i.e., the ACE_Future_Rep). - * The update method of the specified subject will be invoked with a copy of - * the written-to ACE_Future as input when the result gets set. - * - * Returns 0 if the observer is successfully attached, 1 if the - * observer is already attached, and -1 if failures occur. - */ - int attach (ACE_Future_Observer *observer, - ACE_Future &caller); - - /** - * Detaches the specified observer from a subject (i.e., the ACE_Future_Rep). - * The update method of the specified subject will not be invoked when the - * ACE_Future_Reps result gets set. Returns 1 if the specified observer was - * actually attached to the subject prior to this call and 0 if was not. - * - * Returns 0 if the observer was successfully detached, and -1 if the - * observer was not attached in the first place. - */ - int detach (ACE_Future_Observer *observer); - - /** - * Type conversion. will block forever until the result is - * available. Note that this method is going away in a subsequent - * release since it doesn't distinguish between failure results and - * success results (exceptions should be used, but they aren't - * portable...). The method should be used instead since it - * separates the error value from the result, and also permits - * timeouts. - */ - operator T (); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - // = Encapsulate reference count and object lifetime of instances. - - // These methods must go after the others to work around a bug with - // Borland's C++ Builder... - - /// Allocate a new ACE_Future_Rep instance, returning NULL if it - /// cannot be created. - static ACE_Future_Rep *internal_create (void); - - /// Create a ACE_Future_Rep and initialize the reference count. - static ACE_Future_Rep *create (void); - - /** - * Increase the reference count and return argument. Uses the - * attribute "value_ready_mutex_" to synchronize reference count - * updating. - * - * Precondition (rep != 0). - */ - static ACE_Future_Rep *attach (ACE_Future_Rep *&rep); - - /** - * Decreases the reference count and deletes rep if there are no - * more references to rep. - * - * Precondition (rep != 0) - */ - static void detach (ACE_Future_Rep *&rep); - - /** - * Decreases the rep's reference count and deletes rep if there - * are no more references to rep. Then assigns new_rep to rep. - * - * Precondition (rep != 0 && new_rep != 0) - */ - static void assign (ACE_Future_Rep *&rep, ACE_Future_Rep *new_rep); - - /// Is result available? - int ready (void) const; - - /// Pointer to the result. - T *value_; - - /// Reference count. - int ref_count_; - - typedef ACE_Future_Observer OBSERVER; - - typedef ACE_Unbounded_Set OBSERVER_COLLECTION; - - /// Keep a list of ACE_Future_Observers unread by client's reader thread. - OBSERVER_COLLECTION observer_collection_; - - // = Condition variable and mutex that protect the . - mutable ACE_SYNCH_RECURSIVE_MUTEX value_ready_mutex_; - mutable ACE_SYNCH_RECURSIVE_CONDITION value_ready_; - -private: - ACE_Future_Rep (void); - -protected: - ~ACE_Future_Rep (void); -}; - -/** - * @class ACE_Future - * - * @brief This class implements a ``single write, multiple read'' - * pattern that can be used to return results from asynchronous - * method invocations. - */ -template -class ACE_Future -{ -public: - /// Constructor. - ACE_Future (void); - - /// Copy constructor binds @a this and @a r to the same - /// ACE_Future_Rep. An ACE_Future_Rep is created if necessary. - ACE_Future (const ACE_Future &r); - - /// Constructor that initialises an ACE_Future to point to the - /// result @a r immediately. - ACE_Future (const T &r); - - /// Destructor. - ~ACE_Future (void); - - /// Assignment operator that binds @a this and @a r to the same - /// ACE_Future_Rep. An ACE_Future_Rep is created if necessary. - void operator = (const ACE_Future &r); - - /// Cancel an ACE_Future and assign the value @a r. It is used if a - /// client does not want to wait for the value to be produced. - int cancel (const T &r); - - /** - * Cancel an ACE_Future. Put the future into its initial - * state. Returns 0 on succes and -1 on failure. It is now possible - * to reuse the ACE_Future. But remember, the ACE_Future - * is now bound to a new ACE_Future_Rep. - */ - int cancel (void); - - /** - * Equality operator that returns @c true if both ACE_Future objects - * point to the same ACE_Future_Rep object. - * - * @note It also returns @c true if both objects have just been - * instantiated and not used yet. - */ - bool operator == (const ACE_Future &r) const; - - /// Inequality operator, which is the opposite of equality. - bool operator != (const ACE_Future &r) const; - - /** - * Make the result available. Is used by the server thread to give - * the result to all waiting clients. Returns 0 for success, -1 on failure. - * This function only has an effect the first time it is called for - * the object (actually, the first time the underlying ACE_Future_Rep has a - * value assigned to it). Subsequent calls return 0 (success) but have no - * effect. - */ - int set (const T &r); - - /** - * Wait to get the object's value. - * - * @param value Receives the value of this ACE_Future when it is set. - * @param tv Pointer to an ACE_Time_Value containing the absolute - * time to wait until for the value to be set. If @a tv - * is 0, the call waits indefinitely for the value to be - * set, unless an error occurs. - * - * @retval 0 Success; @a value contains the value of the ACE_Future. - * @retval -1 Error; check ACE_OS::last_error() for an error code. - */ - int get (T &value, ACE_Time_Value *tv = 0) const; - - /** - * @deprecated Note that this method is going away in a subsequent - * release since it doesn't distinguish between failure - * results and success results (exceptions should be - * used, but they aren't portable...). - * Type conversion, which obtains the result of the asynchronous - * method invocation. Will block forever. The get() method should be - * used instead since it separates the error value from the result, - * and also permits timeouts. - */ - operator T (); - - /// Check if the result is available. - int ready (void) const; - - /** - * Attaches the specified observer to a subject (this ACE_Future). - * The update method of the specified subject will be invoked with a copy of - * the associated ACE_Future as input when the result gets set. If the - * result is already set when this method gets invoked, then the update - * method of the specified subject will be invoked immediately. - * - * @param observer The observer to attach to the subject. - * - * @retval 0 Success. - * @retval 1 The observer was already attached. - * @retval -1 Error; check ACE_OS::last_error() for an error code. - */ - int attach (ACE_Future_Observer *observer); - - /** - * Detaches the specified observer from a subject (this ACE_Future). - * The update method of the specified subject will not be invoked when the - * ACE_Future_Rep result gets set. - * - * @param observer The observer to attach to the subject. - * - * @retval 0 The observer was successfully detached. - * @retval -1 Error, including the observer not attached prior - * to calling this method. - */ - int detach (ACE_Future_Observer *observer); - - /// Dump the state of an object. - void dump (void) const; - - /** - * Get the underlying ACE_Future_Rep pointer. Note that this method should - * rarely, if ever, be used and that modifying the underlying - * ACE_Future_Rep should be done with extreme caution. - */ - ACE_Future_Rep *get_rep (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - - /// The ACE_Future_Rep - /// Protect operations on the . - typedef ACE_Future_Rep FUTURE_REP; - FUTURE_REP *future_rep_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Future.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Future.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#endif /* ACE_HAS_THREADS */ - -#include /**/ "ace/post.h" - -#endif /* ACE_FUTURE_H */ diff --git a/deps/acelite/ace/Future_Set.cpp b/deps/acelite/ace/Future_Set.cpp deleted file mode 100644 index 413539b2a..000000000 --- a/deps/acelite/ace/Future_Set.cpp +++ /dev/null @@ -1,136 +0,0 @@ -#ifndef ACE_FUTURE_SET_CPP -#define ACE_FUTURE_SET_CPP - -#include "ace/Future_Set.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_THREADS) - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_Future_Set) - -template -ACE_Future_Set::ACE_Future_Set (ACE_Message_Queue *new_queue) - : delete_queue_ (false) -{ - if (new_queue) - this->future_notification_queue_ = new_queue; - else - { - ACE_NEW (this->future_notification_queue_, - ACE_Message_Queue); - this->delete_queue_ = true; - } -} - -template -ACE_Future_Set::~ACE_Future_Set (void) -{ - // Detach ourselves from all remaining futures, if any, in our map. - typename FUTURE_HASH_MAP::iterator iterator = - this->future_map_.begin (); - - typename FUTURE_HASH_MAP::iterator end = - this->future_map_.end (); - - for (; - iterator != end; - ++iterator) - { - FUTURE_HOLDER *future_holder = (*iterator).int_id_; - future_holder->item_.detach (this); - delete future_holder; - } - - if (this->delete_queue_) - delete this->future_notification_queue_; -} - -template int -ACE_Future_Set::is_empty () const -{ - return (((ACE_Future_Set*)this)->future_map_.current_size () == 0 ); -} - -template int -ACE_Future_Set::insert (ACE_Future &future) -{ - FUTURE_HOLDER *future_holder; - ACE_NEW_RETURN (future_holder, - FUTURE_HOLDER (future), - -1); - - FUTURE_REP *future_rep = future.get_rep (); - int result = this->future_map_.bind (future_rep, - future_holder); - - // If a new map entry was created, then attach to the future, - // otherwise we were already attached to the future or some error - // occurred so just delete the future holder. - if (result == 0) - // Attach ourself to the ACE_Futures list of observer - future.attach (this); - else - delete future_holder; - - return result; -} - -template void -ACE_Future_Set::update (const ACE_Future &future) -{ - ACE_Message_Block *mb = 0; - FUTURE &local_future = const_cast &> (future); - - ACE_NEW (mb, - ACE_Message_Block ((char *) local_future.get_rep (), 0)); - - // Enqueue in priority order. - this->future_notification_queue_->enqueue (mb, 0); -} - -template int -ACE_Future_Set::next_readable (ACE_Future &future, - ACE_Time_Value *tv) -{ - if (this->is_empty ()) - return 0; - - ACE_Message_Block *mb = 0; - FUTURE_REP *future_rep = 0; - - // Wait for a "readable future" signal from the message queue. - if (this->future_notification_queue_->dequeue_head (mb, - tv) != -1) - { - // Extract future rep from the message block. - future_rep = reinterpret_cast (mb->base ()); - - // Delete the message block. - mb->release (); - } - else - return 0; - - // Remove the hash map entry with the specified future rep from our map. - FUTURE_HOLDER *future_holder = 0; - if (this->future_map_.find (future_rep, - future_holder) != -1) - { - future = future_holder->item_; - this->future_map_.unbind (future_rep); - delete future_holder; - return 1; - } - - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_THREADS */ -#endif /* ACE_FUTURE_SET_CPP */ diff --git a/deps/acelite/ace/Future_Set.h b/deps/acelite/ace/Future_Set.h deleted file mode 100644 index 57e8721fc..000000000 --- a/deps/acelite/ace/Future_Set.h +++ /dev/null @@ -1,139 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Future_Set.h - * - * @author John Tucker - */ -//============================================================================= - -#ifndef ACE_FUTURE_SET_H -#define ACE_FUTURE_SET_H -#include /**/ "ace/pre.h" - -#include "ace/Thread.h" -#include "ace/Message_Queue.h" -#include "ace/Future.h" -#include "ace/Hash_Map_Manager_T.h" -#include "ace/Null_Mutex.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -#pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_THREADS) - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Future_Set - * - * @brief This class implements a mechanism that allows the values of - * a collection of ACE_Future objects to be accessed by reader threads - * as they become available. The caller(s) provide the ACE_Future_Set - * (i.e. the observer...) with the collection of ACE_Future objects - * (i.e. the subjects...) that are to be observed using the the - * ACE_Future_Set::insert() method. The caller(s) may then iterate - * over the collection in the order in which they become readable - * using the ACE_Future_Set::next_readable() method. - */ -template -class ACE_Future_Set : public ACE_Future_Observer, - private ACE_Copy_Disabled -{ -public: - /// Constructor. - ACE_Future_Set (ACE_Message_Queue *future_notification_queue_ = 0); - - /// Destructor. - ~ACE_Future_Set (void); - - /** - * Return 1 if their are no ACE_Future objects left on its queue and - * 0 otherwise. - * - * When an ACE_Future_Set has no ACE_Future>subjects to observe it is - * empty. The ACE_Future_Set is in the empty state when either the caller(s) - * have retrieved every readable ACE_Future subject assigned the - * ACE_Future_Set via the ACE_Future_Set::next_readable() method, - * or when the ACE_Future_Set has not been assigned any subjects. - */ - int is_empty (void) const; - - /** - * Enqueus the given ACE_Future into this objects queue when it is - * readable. - * - * Returns 0 if the future is successfully inserted, 1 if the - * future is already inserted, and -1 if failures occur. - */ - int insert (ACE_Future &future); - - /** - * Wait up to @a tv time to get the @a value. Note that @a tv must be - * specified in absolute time rather than relative time.); get the - * next ACE_Future that is readable. If @a tv = 0, the will block - * forever. - * - * If a readable future becomes available, then the input - * ACE_Future object param will be assigned with it and 1 will - * be returned. If the ACE_Future_Set is empty (i.e. see definition - * of ACE_Future_Set::is_empty()), then 0 is returned. - * - * When a readable ACE_Future object is retrieved via the - * ACE_Future_Set::next_readable() method, the ACE_Future_Set will - * remove that ACE_Future object from its list of subjects. - */ - int next_readable (ACE_Future &result, - ACE_Time_Value *tv = 0); - - /// Called by the ACE_Future subject in which we are subscribed to - /// when its value is written to. - virtual void update (const ACE_Future &future); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - typedef ACE_Future FUTURE; - - typedef ACE_Future_Rep FUTURE_REP; - - typedef ACE_Future_Holder FUTURE_HOLDER; - - typedef ACE_Pointer_Hash FUTURE_REP_HASH; - - typedef ACE_Equal_To FUTURE_REP_COMPARE; - - typedef ACE_Hash_Map_Manager_Ex FUTURE_HASH_MAP; - - /// Map of , subjects, which have not been written to by - /// client's writer thread. - FUTURE_HASH_MAP future_map_; - - /// Message queue for notifying the reader thread of which - /// have been written to by client's writer thread. - ACE_Message_Queue *future_notification_queue_; - - /// Keeps track of whether we need to delete the message queue. - bool delete_queue_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Future_Set.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Future_Set.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#endif /* ACE_HAS_THREADS */ -#include /**/ "ace/post.h" -#endif /* ACE_FUTURE_SET_H */ diff --git a/deps/acelite/ace/Get_Opt.cpp b/deps/acelite/ace/Get_Opt.cpp deleted file mode 100644 index 9e8d7c1fb..000000000 --- a/deps/acelite/ace/Get_Opt.cpp +++ /dev/null @@ -1,734 +0,0 @@ -#include "ace/Get_Opt.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Get_Opt.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/ACE.h" -#include "ace/Log_Category.h" -#include "ace/SString.h" -#include "ace/OS_Memory.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_NS_ctype.h" -#include "ace/OS_NS_stdlib.h" - -/* - * Copyright (c) 1987, 1993, 1994 - * The Regents of the University of California. All rights reserved. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the University of - * California, Berkeley and its contributors. - * 4. Neither the name of the University nor the names of its contributors - * may be used to endorse or promote products derived from this software - * without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE - * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE - * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE - * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL - * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS - * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) - * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT - * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY - * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF - * SUCH DAMAGE. - */ - -/*- - * Copyright (c) 2000 The NetBSD Foundation, Inc. - * All rights reserved. - * - * This code is derived from software contributed to The NetBSD Foundation - * by Dieter Baron and Thomas Klausner. - * - * Redistribution and use in source and binary forms, with or without - * modification, are permitted provided that the following conditions - * are met: - * 1. Redistributions of source code must retain the above copyright - * notice, this list of conditions and the following disclaimer. - * 2. Redistributions in binary form must reproduce the above copyright - * notice, this list of conditions and the following disclaimer in the - * documentation and/or other materials provided with the distribution. - * 3. All advertising materials mentioning features or use of this software - * must display the following acknowledgement: - * This product includes software developed by the NetBSD - * Foundation, Inc. and its contributors. - * 4. Neither the name of The NetBSD Foundation nor the names of its - * contributors may be used to endorse or promote products derived - * from this software without specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS - * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED - * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR - * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS - * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR - * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF - * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS - * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN - * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - * POSSIBILITY OF SUCH DAMAGE. - */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Get_Opt) - -#ifdef ACE_USES_WCHAR -void ACE_Get_Opt::ACE_Get_Opt_Init (const ACE_TCHAR *optstring) -#else -ACE_Get_Opt::ACE_Get_Opt (int argc, - ACE_TCHAR **argv, - const ACE_TCHAR *optstring, - int skip, - int report_errors, - int ordering, - int long_only) - : argc_ (argc), - argv_ (argv), - optind (skip), - opterr (report_errors), - optarg (0), - optstring_ (0), - long_only_ (long_only), - has_colon_ (0), - last_option_ (0), - nextchar_ (0), - optopt_ (0), - ordering_ (ordering), - nonopt_start_ (optind), - nonopt_end_ (optind), - long_option_ (0) -#endif -{ - ACE_TRACE ("ACE_Get_Opt::ACE_Get_Opt"); - - ACE_NEW (this->optstring_, ACE_TString (optstring)); - ACE_NEW (this->last_option_, ACE_TString (ACE_TEXT (""))); - - // First check to see if POSIXLY_CORRECT was set. - // Win32 is the only platform capable of wide-char env var. -#if defined (ACE_WIN32) - const ACE_TCHAR *env_check = ACE_TEXT ("POSIXLY_CORRECT"); -#else - const char *env_check = "POSIXLY_CORRECT"; -#endif - if (ACE_OS::getenv (env_check) != 0) - this->ordering_ = REQUIRE_ORDER; - - // Now, check to see if any or the following were passed at - // the beginning of optstring: '+' same as POSIXLY_CORRECT; - // '-' turns off POSIXLY_CORRECT; or ':' which signifies we - // should return ':' if a parameter is missing for an option. - // We use a loop here, since a combination of "{+|-}:" in any - // order should be legal. - int done = 0; - int offset = 0; - while (!done) - { - switch (optstring[offset++]) - { - case '+': - this->ordering_ = REQUIRE_ORDER; - break; - case '-': - this->ordering_ = RETURN_IN_ORDER; - break; - case ':': - this->has_colon_ = 1; - break; - default: - // Quit as soon as we see something else... - done = 1; - break; - } - } -} - -ACE_Get_Opt::~ACE_Get_Opt (void) -{ - ACE_TRACE ("ACE_Get_Opt::~ACE_Get_Opt"); - - size_t i = 0; - size_t size = this->long_opts_.size (); - ACE_Get_Opt_Long_Option *option = 0; - for (i = 0; i < size; ++i) - { - int retval = this->long_opts_.get (option, i); - if (retval != 0) - { - // Should never happen. - retval = 0; - continue; - } - if (option) - { - delete option; - option = 0; - } - } - delete this->optstring_; - delete this->last_option_; -} - -int -ACE_Get_Opt::nextchar_i (void) -{ - ACE_TRACE ("ACE_Get_Opt::nextchar_i"); - - if (this->ordering_ == PERMUTE_ARGS) - if (this->permute () == EOF) - return EOF; - - // Update scanning pointer. - if (this->optind >= this->argc_) - { - // We're done... - this->nextchar_ = 0; - return EOF; - } - else if (*(this->nextchar_ = this->argv_[this->optind]) != '-' - || this->nextchar_[1] == '\0') - { - // We didn't get an option. - - if (this->ordering_ == REQUIRE_ORDER - || this->ordering_ == PERMUTE_ARGS) - // If we permuted or require the options to be in order, we're done. - return EOF; - - // It must be RETURN_IN_ORDER... - this->optarg = this->argv_[this->optind++]; - this->nextchar_ = 0; - return 1; - } - else if (this->nextchar_[1] != 0 - && *++this->nextchar_ == '-' - && this->nextchar_[1] == 0) - { - // Found "--" so we're done... - ++this->optind; - this->nextchar_ = 0; - return EOF; - } - - // If it's a long option, and we allow long options advance nextchar_. - if (*this->nextchar_ == '-' && this->long_opts_.size () != 0) - this->nextchar_++; - - return 0; -} - -int -ACE_Get_Opt::long_option_i (void) -{ - ACE_TRACE ("ACE_Get_Opt::long_option_i"); - - ACE_Get_Opt_Long_Option *p; - ACE_TCHAR *s = this->nextchar_; - int hits = 0; - int exact = 0; - ACE_Get_Opt_Long_Option *pfound = 0; - int indfound = 0; - - // Advance to the end of the long option name so we can use - // it to get the length for a string compare. - while (*s && *s != '=') - s++; - - size_t len = s - this->nextchar_; - // set last_option_ to nextchar_, up to the '='. - this->last_option (ACE_TString (this->nextchar_, len)); - - size_t size = this->long_opts_.size (); - u_int option_index = 0; - for (option_index = 0; option_index < size ; option_index++) - { - p = this->long_opts_[option_index]; - ACE_ASSERT (p); - - if (!ACE_OS::strncmp (p->name_, this->nextchar_, len)) - { - // Got at least a partial match. - pfound = p; - indfound = option_index; - hits += 1; - if (len == ACE_OS::strlen(p->name_)) - { - // And in fact, it's an exact match, so let's use it. - exact = 1; - break; - } - } - } - - if ((hits > 1) && !exact) - { - // Great, we found a match, but unfortunately we found more than - // one and it wasn't exact. - if (this->opterr) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%s: option `%s' is ambiguous\n"), - this->argv_[0], this->argv_[this->optind])); - this->nextchar_ = 0; - this->optind++; - return '?'; - } - - if (pfound != 0) - { - // Okay, we found a good one (either a single hit or an exact match). - option_index = indfound; - this->optind++; - if (*s) - { - // s must point to '=' which means there's an argument (well - // close enough). - if (pfound->has_arg_ != NO_ARG) - // Good, we want an argument and here it is. - this->optarg = ++s; - else - { - // Whoops, we've got what looks like an argument, but we - // don't want one. - if (this->opterr) - ACELIB_ERROR - ((LM_ERROR, - ACE_TEXT ("%s: long option `--%s' doesn't allow ") - ACE_TEXT ("an argument\n"), - this->argv_[0], pfound->name_)); - // The spec doesn't cover this, so we keep going and the program - // doesn't know we ignored an argument if opt_err is off!!! - } - } - else if (pfound->has_arg_ == ARG_REQUIRED) - { - // s didn't help us, but we need an argument. Note that - // optional arguments for long options must use the "=" syntax, - // so we won't get here in that case. - if (this->optind < this->argc_) - // We still have some elements left, so use the next one. - this->optarg = this->argv_[this->optind++]; - else - { - // All out of elements, so we have to punt... - if (this->opterr) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%s: long option '--%s' requires ") - ACE_TEXT ("an argument\n"), - this->argv_[0], pfound->name_)); - this->nextchar_ = 0; - this->optopt_ = pfound->val_; // Remember matching short equiv - return this->has_colon_ ? ':' : '?'; - } - } - this->nextchar_ = 0; - this->long_option_ = pfound; - // Since val_ has to be either a valid short option or 0, this works - // great. If the user really wants to know if a long option was passed. - this->optopt_ = pfound->val_; - return pfound->val_; - } - if (!this->long_only_ || this->argv_[this->optind][1] == '-' - || this->optstring_->find (*this->nextchar_) == ACE_TString::npos) - { - // Okay, we couldn't find a long option. If it isn't long_only (which - // means try the long first, and if not found try the short) or a long - // signature was passed, e.g. "--", or it's not a short (not sure when - // this could happen) it's an error. - if (this->opterr) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%s: illegal long option '--%s'\n"), - this->argv_[0], this->nextchar_)); - this->nextchar_ = 0; - this->optind++; - return '?'; - } - return this->short_option_i (); -} - -int -ACE_Get_Opt::short_option_i (void) -{ - ACE_TRACE ("ACE_Get_Opt::short_option_i"); - - /* Look at and handle the next option-character. */ - ACE_TCHAR opt = *this->nextchar_++; - // Set last_option_ to opt - this->last_option (opt); - - ACE_TCHAR *oli = 0; - oli = - const_cast (ACE_OS::strchr (this->optstring_->c_str (), opt)); - - /* Increment `optind' when we start to process its last character. */ - if (*this->nextchar_ == '\0') - ++this->optind; - - if (oli == 0 || opt == ':') - { - if (this->opterr) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%s: illegal short option -- %c\n"), - this->argv_[0], opt)); - return '?'; - } - if (opt == 'W' && oli[1] == ';') - { - if (this->nextchar_[0] == 0) - this->nextchar_ = this->argv_[this->optind]; - return long_option_i (); - } - this->optopt_ = oli[0]; // Remember the option that matched - if (oli[1] == ':') - { - if (oli[2] == ':') - { - // Takes an optional argument, and since short option args must - // must follow directly in the same argument, a NULL nextchar_ - // means we didn't get one. - if (*this->nextchar_ != '\0') - { - this->optarg = this->nextchar_; - this->optind++; - } - else - this->optarg = 0; - this->nextchar_ = 0; - } - else - { - // Takes a required argument. - if (*this->nextchar_ != '\0') - { - // Found argument in same argv-element. - this->optarg = this->nextchar_; - this->optind++; - } - else if (this->optind == this->argc_) - { - // Ran out of arguments before finding required argument. - if (this->opterr) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%s: short option requires ") - ACE_TEXT ("an argument -- %c\n"), - this->argv_[0], opt)); - opt = this->has_colon_ ? ':' : '?'; - } - else - // Use the next argv-element as the argument. - this->optarg = this->argv_[this->optind++]; - this->nextchar_ = 0; - } - } - return opt; -} - -int -ACE_Get_Opt::operator () (void) -{ - ACE_TRACE ("ACE_Get_Opt_Long::operator"); - - // First of all, make sure we reinitialize any pointers.. - this->optarg = 0; - this->long_option_ = 0; - - if (this->argv_ == 0) - { - // It can happen, e.g., on VxWorks. - this->optind = 0; - return -1; - } - - // We check this because we can string short options together if the - // preceding one doesn't take an argument. - if (this->nextchar_ == 0 || *this->nextchar_ == '\0') - { - int retval = this->nextchar_i (); - if (retval != 0) - return retval; - } - - if (((this->argv_[this->optind][0] == '-') - && (this->argv_[this->optind][1] == '-')) || this->long_only_) - return this->long_option_i (); - - return this->short_option_i (); -} - -int -ACE_Get_Opt::long_option (const ACE_TCHAR *name, - OPTION_ARG_MODE has_arg) -{ - ACE_TRACE ("ACE_Get_Opt::long_option (const ACE_TCHAR *name, OPTION_ARG_MODE has_arg)"); - return this->long_option (name, 0, has_arg); -} - -int -ACE_Get_Opt::long_option (const ACE_TCHAR *name, - int short_option, - OPTION_ARG_MODE has_arg) -{ - ACE_TRACE ("ACE_Get_Opt::long_option (const ACE_TCHAR *name, int short_option, OPTION_ARG_MODE has_arg)"); - - // We only allow valid alpha-numeric characters as short options. - // If short_options is not a valid alpha-numeric, we can still return it - // when the long option is found, but won't allow the caller to pass it on - // the command line (how could they?). The special case is 0, but since - // we always return it, we let the caller worry about that. - if (ACE_OS::ace_isalnum (short_option) != 0) - { - // If the short_option already exists, make sure it matches, otherwise - // add it. - ACE_TCHAR *s = 0; - if ((s = const_cast ( - ACE_OS::strchr (this->optstring_->c_str (), - short_option))) != 0) - { - // Short option exists, so verify the argument options - if (s[1] == ':') - { - if (s[2] == ':') - { - if (has_arg != ARG_OPTIONAL) - { - if (this->opterr) - ACELIB_ERROR - ((LM_ERROR, - ACE_TEXT ("Existing short option '%c' takes ") - ACE_TEXT ("optional argument; adding %s ") - ACE_TEXT ("requires ARG_OPTIONAL\n"), - short_option, name)); - return -1; - } - } - else - if (has_arg != ARG_REQUIRED) - { - if (this->opterr) - ACELIB_ERROR - ((LM_ERROR, - ACE_TEXT ("Existing short option '%c' requires ") - ACE_TEXT ("an argument; adding %s ") - ACE_TEXT ("requires ARG_REQUIRED\n"), - short_option, name)); - return -1; - } - } - else if (has_arg != NO_ARG) - { - if (this->opterr) - ACELIB_ERROR - ((LM_ERROR, - ACE_TEXT ("Existing short option '%c' does not ") - ACE_TEXT ("accept an argument; adding %s ") - ACE_TEXT ("requires NO_ARG\n"), - short_option, name)); - return -1; - } - } - else - { - // Didn't find short option, so add it... - *this->optstring_ += (ACE_TCHAR) short_option; - if (has_arg == ARG_REQUIRED) - *this->optstring_ += ACE_TEXT (":"); - else if (has_arg == ARG_OPTIONAL) - *this->optstring_ += ACE_TEXT ("::"); - } - } - - ACE_Get_Opt_Long_Option *option = - new ACE_Get_Opt_Long_Option (name, has_arg, short_option); - - if (!option) - return -1; - - // Add to array - size_t size = this->long_opts_.size (); - if (this->long_opts_.size (size + 1) != 0 - || this->long_opts_.set (option, size) != 0) - { - delete option; - ACELIB_ERROR_RETURN - ((LM_ERROR, ACE_TEXT ("Could not add long option to array.\n")), - -1); - } - return 0; -} - -const ACE_TCHAR* -ACE_Get_Opt::long_option (void) const -{ - ACE_TRACE ("ACE_Get_Opt::long_option (void)"); - if (this->long_option_) - return this->long_option_->name_; - return 0; -} - -const ACE_TCHAR* -ACE_Get_Opt::last_option (void) const -{ - return this->last_option_->c_str (); -} - -void -ACE_Get_Opt::last_option (const ACE_TString &last_option) -{ - *this->last_option_ = last_option; -} - -void -ACE_Get_Opt::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Get_Opt::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n") - ACE_TEXT ("opstring_ = %s\n") - ACE_TEXT ("long_only_ = %d\n") - ACE_TEXT ("has_colon_ = %d\n") - ACE_TEXT ("last_option_ = %s\n") - ACE_TEXT ("nextchar_ = %s\n") - ACE_TEXT ("optopt_ = %c\n") - ACE_TEXT ("ordering_ = %d\n"), - this->optstring_->c_str (), - this->long_only_, - this->has_colon_, - this->last_option_->c_str (), - this->nextchar_, - this->optopt_, - this->ordering_)); - - // now loop through the - size_t size = this->long_opts_.size (); - for (u_int i = 0; i < size ; ++i) - { - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n") - ACE_TEXT ("long_option name_ = %s\n") - ACE_TEXT ("has_arg_ = %d\n") - ACE_TEXT ("val_ = %d\n"), - this->long_opts_[i]->name_, - this->long_opts_[i]->has_arg_, - this->long_opts_[i]->val_)); - } - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -void -ACE_Get_Opt::permute_args (void) -{ - ACE_TRACE ("ACE_Get_Opt::permute_args"); - - u_long cyclelen, i, j, ncycle, nnonopts, nopts; - u_long opt_end = this->optind; - int cstart, pos = 0; - ACE_TCHAR *swap = 0; - - nnonopts = this->nonopt_end_ - this->nonopt_start_; - nopts = opt_end - this->nonopt_end_; - ncycle = ACE::gcd (nnonopts, nopts); - cyclelen = (opt_end - this->nonopt_start_) / ncycle; - - this->optind = this->optind - nnonopts; - - for (i = 0; i < ncycle; i++) - { - cstart = this->nonopt_end_ + i; - pos = cstart; - for (j = 0; j < cyclelen; j++) - { - if (pos >= this->nonopt_end_) - pos -= nnonopts; - else - pos += nopts; - swap = this->argv_[pos]; - - ((ACE_TCHAR **)this->argv_)[pos] = argv_[cstart]; - - ((ACE_TCHAR **)this->argv_)[cstart] = swap; - } - } -} - -int -ACE_Get_Opt::permute (void) -{ - ACE_TRACE ("ACE_Get_Opt::permute"); - - if (this->nonopt_start_ != this->nonopt_end_ - && this->nonopt_start_ != this->optind) - this->permute_args (); - - this->nonopt_start_ = this->optind; - - // Skip over args untill we find the next option. - while (this->optind < this->argc_ - && (this->argv_[this->optind][0] != '-' - || this->argv_[this->optind][1] == '\0')) - this->optind++; - - // Got an option, so mark this as the end of the non options. - this->nonopt_end_ = this->optind; - - if (this->optind != this->argc_ - && ACE_OS::strcmp (this->argv_[this->optind], - ACE_TEXT ("--")) == 0) - { - // We found the marker for the end of the options. - ++this->optind; - - if (this->nonopt_start_ != this->nonopt_end_ - && this->nonopt_end_ != this->optind) - this->permute_args (); - } - - if (this->optind == this->argc_) - { - if (this->nonopt_start_ != this->nonopt_end_) - this->optind = this->nonopt_start_; - return EOF; - } - return 0; -} - -const ACE_TCHAR * -ACE_Get_Opt::optstring (void) const -{ - return this->optstring_->c_str (); -} - -ACE_Get_Opt::ACE_Get_Opt_Long_Option::ACE_Get_Opt_Long_Option ( - const ACE_TCHAR *name, - int has_arg, - int val) - : name_ (ACE::strnew (name)), - has_arg_ (has_arg), - val_ (val) -{} - -ACE_Get_Opt::ACE_Get_Opt_Long_Option::~ACE_Get_Opt_Long_Option (void) -{ -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(const_cast(this->name_)); -#else - delete [] this->name_; -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Get_Opt::ACE_Get_Opt_Long_Option); - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Get_Opt.h b/deps/acelite/ace/Get_Opt.h deleted file mode 100644 index fbe64a18a..000000000 --- a/deps/acelite/ace/Get_Opt.h +++ /dev/null @@ -1,493 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Get_Opt.h - * - * @author Douglas C. Schmidt - * @author Don Hinton (added long option support) - */ -//========================================================================== - -#ifndef ACE_GET_OPT_H -#define ACE_GET_OPT_H -#include /**/ "ace/pre.h" - -#include "ace/SStringfwd.h" -#include "ace/Containers.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#undef optind -#undef optarg -#undef opterr - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/* - * These definitions are for backward compatibility with previous versions. - * of ACE_Get_Opt. - */ - -/** - * @class ACE_Get_Opt - * - * @brief Iterator for parsing command-line arguments. - * - * This is a C++ wrapper for getopt(3c) and getopt_long(3c). - */ -class ACE_Export ACE_Get_Opt -{ -public: - /// Mutually exclusive ordering values. - enum - { - /** - * REQUIRE_ORDER means that processing stops and @c EOF is - * returned as soon as a non-option argument is found. @c opt_ind() - * will return the index of the next @a argv element so the program - * can continue processing the rest of the @a argv elements. - */ - REQUIRE_ORDER = 1, - - /** - * PERMUTE_ARGS means the @a argv elements are reordered dynamically - * (permuted) so that all options appear first. When the elements are - * permuted, the order of the options and the following arguments are - * maintained. When the last option has been processed, @c EOF is - * returned and @c opt_ind() returns the index into the next non-option - * element. - */ - PERMUTE_ARGS = 2, - - /** - * RETURN_IN_ORDER means each @a argv element is processed in the - * order is it seen. If the element is not recognized as an option, '1' - * is returned and @c opt_arg() refers to the @a argv element found. - */ - RETURN_IN_ORDER = 3 - }; - - /// Mutually exclusive option argument mode used by long options. - enum OPTION_ARG_MODE - { - /// Doesn't take an argument. - NO_ARG = 0, - - /// Requires an argument, same as passing ":" after a short option - /// character in @a optstring. - ARG_REQUIRED = 1, - - /// Argument is optional, same as passing "::" after a short - /// option character in @a optstring. - ARG_OPTIONAL = 2 - }; - - /** - * Constructor initializes the command line to be parsed. All information - * for parsing must be supplied to this constructor. - * - * @param argc The number of @a argv elements to parse. - * @param argv Command line tokens, such as would be passed - * to @c main(). - * @param optstring Nul-terminated string containing the legitimate - * short option characters. A single colon ":" - * following an option character means the option - * requires an argument. A double colon "::" following - * an option character means the argument is optional. - * The argument is taken from the rest of the current - * @a argv element, or from the following @a argv - * element (only valid for required arguments; - * optional arguments must always reside in the same - * @a argv element). The argument value, if any is - * returned by the @c opt_arg() method. - * @a optstring can be extended by adding long options - * with corresponding short options via the - * @c long_option() method. If the short option - * already appears in @a optstring, the argument - * characteristics must match, otherwise it is added. - * See @c long_option() for more information. - * If 'W', followed by a semi-colon ';' appears in - * @a optstring, then any time a 'W' appears on the - * command line, the following argument is treated as - * a long option. For example, if the command line - * contains "program -W foo", "foo" is treated as a - * long option, that is, as if "program --foo" had - * been passed. - * The following characters can appear in @a optstring - * before any option characters, with the described - * effect: - * - '+' changes the @a ordering to @a REQUIRE_ORDER. - * - '-' changes the @a ordering to @a RETURN_IN_ORDER. - * - ':' changes the return value from @c operator() - * and get_opt() from '?' to ':' when an option - * requires an argument but none is specified. - * - * @param skip_args Optional (default 1). The specified number of - * initial elements in @a argv are skipped before - * parsing begins. Thus, the default prevents - * @a argv[0] (usually the command name) from being - * parsed. @a argc includes all @a argv elements, - * including any skipped elements. - * @param report_errors Optional, if non-zero then parsing errors cause - * an error message to be displayed from the - * @c operator() method before it returns. The - * error message is suppressed if this argument is 0. - * This setting also controls whether or not an error - * message is displayed in @c long_option() encounters - * an error. - * @param ordering Optional (default is @c PERMUTE_ARGS); determines - * how the @a argv elements are processed. This argument - * is overridden by two factors: - * -# The @c POSIXLY_CORRECT environment variable. If - * this environment variable is set, the ordering - * is changed to @c REQUIRE_ORDER. - * -# Leading characters in @a optstring (see above). - * Any leading ordering characters override both - * the @a ordering argument and any effect of the - * @c POSIXLY_CORRECT environment variable. - * @param long_only Optional. If non-zero, then long options can be - * specified using a single '-' on the command line. - * If the token is not a long option, it is processed - * as usual, that is, as a short option or set of - * short options. - * - * Multiple short options can be combined as long as only the last - * one can takes an argument. For example, if @a optstring is defined as - * @c "abc:" or @c "abc::" then the command line @e "program -abcxxx" short - * options @e a, @e b, and @e c are found with @e "xxx" as the argument for - * @e c. - * However, if the command line is specified as @e "program -acb" only - * options @e a and @e c are found with @e "b" as the argument for @e c. - * Also, for options with optional arguments, that is, those followed by - * "::", the argument must be in the same @a argv element, so "program -abc - * xxx" will only find "xxx" as the argument for @e c if @a optstring is - * specified as @c "abc:" not @c "abc::". - */ -#ifndef ACE_USES_WCHAR - ACE_Get_Opt (int argc, - ACE_TCHAR **argv, - const ACE_TCHAR *optstring = ACE_TEXT (""), - int skip_args = 1, - int report_errors = 0, - int ordering = PERMUTE_ARGS, - int long_only = 0); - -#else -private: - void ACE_Get_Opt_Init (const ACE_TCHAR *optstring); -public: - ACE_Get_Opt (int argc, - ACE_TCHAR **argv, - const ACE_TCHAR *optstring = ACE_TEXT (""), - int skip_args = 1, - int report_errors = 0, - int ordering = PERMUTE_ARGS, - int long_only = 0); - ACE_Get_Opt (int argc, - ACE_TCHAR **argv, - const char *optstring, - int skip_args = 1, - int report_errors = 0, - int ordering = PERMUTE_ARGS, - int long_only = 0); -#endif - /// Default dtor. - ~ACE_Get_Opt (void); - - /** - * Scan elements of @a argv (whose length is @a argc) for short option - * characters given in @a optstring or long options (with no short - * option equivalents). - * - * If an element of @a argv starts with '-', and is not exactly "-" - * or "--", then it is a short option element. The characters of this - * element (aside from the initial '-') are option characters. If - * it starts with "--" followed by other characters it is treated as - * a long option. If @c operator() is called repeatedly, it returns - * each of the option characters from each of the option elements. - * - * @return The parsed option character. The following characters have - * special significance. - * @retval 0 A long option was found - * @retval '\?' Either an unknown option character was found, or the - * option is known but requires an argument, none was - * specified, and @a optstring did not contain a leading - * colon. - * @retval ':' A known option character was found but it requires an - * argument and none was supplied, and the first character - * of @a optstring was a colon. @c opt_opt() indicates - * which option was specified. - * @retval '1' @c RETURN_IN_ORDER was specified and a non-option argument - * was found. - * @retval EOF No more option characters were found. @c opt_ind() will - * return the index in @a argv of the first @a argv element - * that is not an option. If @c PERMUTE_ARGS was - * specified, the @a argv elements have been permuted so that - * those that are not options now come last. - * - * @note The standards are unclear with respect to the conditions under - * which '?' and ':' are returned, so we scan the initial characters of - * @a optstring up unto the first short option character for '+', '-', - * and ':' in order to determine ordering and missing argument behavior. - */ - int operator () (void); - - /** - * For communication from @c operator() to the caller. When - * @c operator() finds an option that takes an argument, the argument - * value is returned from this method, otherwise it returns 0. - */ - ACE_TCHAR *opt_arg (void) const; - - /** - * Returns the most recently matched option character. Especially - * useful when operator() returns ':' for an unspecified argument - * that's required, since this allows the caller to learn what option - * was specified without its required argument. - */ - int opt_opt (void); - - /** - * Index in @a argv of the next element to be scanned. This is used - * for communication to and from the caller and for communication - * between successive calls to @c operator(). On entry to - * @c operator(), zero means this is the first call; initialize. - * - * When @c operator() returns @c EOF, this is the index of the first of - * the non-option elements that the caller should itself scan. - * - * Otherwise, @c opt_ind() communicates from one call to the next how - * much of @a argv has been scanned so far. - */ - int &opt_ind (void); - - /// Adds a long option with no corresponding short option. - /** - * If the @a name option is seen, @c operator() returns 0. - * - * @param name The long option to add. - * @param has_arg Defines the argument requirements for - * the new option. - * - * @retval 0 Success - * @retval -1 The long option can not be added. - */ - int long_option (const ACE_TCHAR *name, - OPTION_ARG_MODE has_arg = NO_ARG); - - /// Adds a long option with a corresponding short option. - /** - * @param name The long option to add. - * @param short_option A character, the short option that corresponds - * to @a name. - * @param has_arg Defines the argument requirements for - * the new option. If the short option has already - * been supplied in the @a optstring, @a has_arg - * must match or an error is returned; otherwise, the - * new short option is added to the @a optstring. - * - * @retval 0 Success - * @retval -1 The long option can not be added. - */ - int long_option (const ACE_TCHAR *name, - int short_option, - OPTION_ARG_MODE has_arg = NO_ARG); - - /// Returns the name of the long option found on the last call to - /// @c operator() or 0 if none was found. - const ACE_TCHAR *long_option (void) const; - - /// The number of arguments in the internal @c argv_. - int argc (void) const; - - /// Accessor for the internal @c argv_ pointer. - ACE_TCHAR **argv (void) const; - - /// Accessor for the @c last_option that was processed. This allows - /// applications to know if the found option was a short or long - /// option, and is especially useful in cases where it was invalid - /// and the caller wants to print out the invalid value. - const ACE_TCHAR *last_option (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Return the @a optstring. This is handy to verify that calls to - /// long_option added short options as expected. - const ACE_TCHAR *optstring (void) const; - -public: - /* - * The following five data members should be private, but that - * would break backwards compatibility. However, we recommend not - * writing code that uses these fields directly. - */ - - /// Holds the @a argc count. - /** - * @deprecated This is public for backwards compatibility only. - * It will be made private in a release of ACE past 5.3. Do not - * write code that relies on this member being public; use the - * @c argc() accessor method instead. - */ - int argc_; - - /// Holds the @a argv pointer. - /** - * @deprecated This is public for backwards compatibility only. - * It will be made private in a release of ACE past 5.3. Do not - * write code that relies on this member being public; use the - * @c argv() accessor method instead. - */ - ACE_TCHAR **argv_; - - /// Index in @c argv_ of the next element to be scanned. - /** - * @deprecated This is public for backwards compatibility only. - * It will be made private in a release of ACE past 5.3. Do not - * write code that relies on this member being public; use the - * @c opt_ind() accessor method instead. - */ - int optind; - - /// Callers store zero here to inhibit the error message for - /// unrecognized options. - /** - * @deprecated This is public for backwards compatibility only. - * It will be made private in a release of ACE past 5.3. Do not - * write code that relies on this member being public; use the - * @a report_errors argument to this class's constructor instead. - */ - int opterr; - - /// Points to the option argument when one is found on last call to - /// @c operator(). - /** - * @deprecated This is public for backwards compatibility only. - * It will be made private in a release of ACE past 5.3. Do not - * write code that relies on this member being public; use the - * @c opt_arg() accessor method instead. - */ - ACE_TCHAR *optarg; - -private: - /** - * @class ACE_Get_Opt_Long_Option This class is for internal use - * in the ACE_Get_Opt class, and is inaccessible to users. - */ - class ACE_Get_Opt_Long_Option - { - public: - /// ctor - ACE_Get_Opt_Long_Option (const ACE_TCHAR *name, - int has_arg, - int val = 0); - - /// Dtor. - ~ACE_Get_Opt_Long_Option (void); - - bool operator < (const ACE_Get_Opt_Long_Option &rhs); - - /// Long option name. - const ACE_TCHAR *name_; - - /// Contains value for . - int has_arg_; - - /// Contains a valid short option character or zero if it doesn't - /// have a corresponding short option. It can also contain a - /// non-printable value that cannot be passed to but - /// will be returned by . This is handy for - /// simplifying long option handling, see tests/Get_Opt_Test.cpp - /// for an example of this technique. - int val_; - - ACE_ALLOC_HOOK_DECLARE; - }; - - /// Updates nextchar_. - int nextchar_i (void); - - /// Handles long options. - int long_option_i (void); - - /// Handles short options. - int short_option_i (void); - - /// If permuting args, this functions manages the nonopt_start_ and - /// nonopt_end_ indexes and makes calls to permute to actually - /// reorder the -elements. - void permute_args (void); - - /// Handles reordering -elements. - int permute (void); - - /// Set last_option. - void last_option (const ACE_TString &s); - - // Disallow copying and assignment. - ACE_Get_Opt (const ACE_Get_Opt &); - ACE_Get_Opt &operator= (const ACE_Get_Opt &); - -private: - - /// Holds the option string. - ACE_TString *optstring_; - - /// Treat all options as long options. - int long_only_; - - /// Keeps track of whether or not a colon was passed in . - /// This is used to determine the return value when required - /// arguments are missing. - int has_colon_; - - /// This is the last option, short or long, that was processed. This - /// is handy to have in cases where the option passed was invalid. - ACE_TString *last_option_; - - /** - * The next char to be scanned in the option-element in which the - * last option character we returned was found. This allows us to - * pick up the scan where we left off * - * If this is zero, or a null string, it means resume the scan - * by advancing to the next -element. - */ - ACE_TCHAR *nextchar_; - - /// Most recently matched short option character. - int optopt_; - - /// Keeps track of ordering mode (default ). - int ordering_; - - /// Index of the first non-option -element found (only valid - /// when permuting). - int nonopt_start_; - - /// Index of the -element following the last non-option element - /// (only valid when permuting). - int nonopt_end_; - - /// Points to the long_option found on last call to . - ACE_Get_Opt_Long_Option *long_option_; - - /// Array of long options. - ACE_Array long_opts_; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Get_Opt.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_GET_OPT_H */ diff --git a/deps/acelite/ace/Get_Opt.inl b/deps/acelite/ace/Get_Opt.inl deleted file mode 100644 index 32de1d85c..000000000 --- a/deps/acelite/ace/Get_Opt.inl +++ /dev/null @@ -1,94 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE bool -ACE_Get_Opt::ACE_Get_Opt_Long_Option::operator < (const ACE_Get_Opt_Long_Option &rhs) -{ - return this->name_ < rhs.name_; -} - -ACE_INLINE int -ACE_Get_Opt::argc (void) const -{ - return this->argc_; -} - -ACE_INLINE ACE_TCHAR ** -ACE_Get_Opt::argv (void) const -{ - return this->argv_; -} - -ACE_INLINE ACE_TCHAR* -ACE_Get_Opt::opt_arg (void) const -{ - return this->optarg; -} - -ACE_INLINE int -ACE_Get_Opt::opt_opt (void) -{ - return this->optopt_; -} - -ACE_INLINE int & -ACE_Get_Opt::opt_ind (void) -{ - return this->optind; -} - -#ifdef ACE_USES_WCHAR -ACE_INLINE ACE_Get_Opt::ACE_Get_Opt (int argc, - ACE_TCHAR **argv, - const ACE_TCHAR *optstring, - int skip_args, - int report_errors, - int ordering, - int long_only) - : argc_ (argc), - argv_ (argv), - optind (skip_args), - opterr (report_errors), - optarg (0), - optstring_ (0), - long_only_ (long_only), - has_colon_ (0), - last_option_ (0), - nextchar_ (0), - optopt_ (0), - ordering_ (ordering), - nonopt_start_ (optind), - nonopt_end_ (optind), - long_option_ (0) -{ - ACE_Get_Opt_Init (optstring); -} - -ACE_INLINE ACE_Get_Opt::ACE_Get_Opt (int argc, - ACE_TCHAR **argv, - const char *optstring, - int skip_args, - int report_errors, - int ordering, - int long_only) - : argc_ (argc), - argv_ (argv), - optind (skip_args), - opterr (report_errors), - optarg (0), - optstring_ (), - long_only_ (long_only), - has_colon_ (0), - last_option_ (0), - nextchar_ (0), - optopt_ (0), - ordering_ (ordering), - nonopt_start_ (optind), - nonopt_end_ (optind), - long_option_ (0) -{ - ACE_Get_Opt_Init (ACE_TEXT_CHAR_TO_TCHAR (optstring)); -} -#endif - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Global_Macros.h b/deps/acelite/ace/Global_Macros.h deleted file mode 100644 index 23d81ef88..000000000 --- a/deps/acelite/ace/Global_Macros.h +++ /dev/null @@ -1,1014 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Global_Macros.h - * - * @author Douglas C. Schmidt - * @author Jesper S. M|ller - * @author and a cast of thousands... - * - * This one is split from the famous OS.h - */ -//============================================================================= - -#ifndef ACE_GLOBAL_MACROS_H -#define ACE_GLOBAL_MACROS_H - -#include /**/ "ace/pre.h" - -// Included just keep compilers that see #pragma dierctive first -// happy. -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include /**/ "ace/config-lite.h" -#include "ace/Assert.h" // For ACE_ASSERT - -// Start Global Macros -# define ACE_BEGIN_DUMP ACE_TEXT ("\n====\n(%P|%t|%x)\n") -# define ACE_END_DUMP ACE_TEXT ("====\n") - -# if defined (ACE_NDEBUG) -# define ACE_DB(X) -# else -# define ACE_DB(X) X -# endif /* ACE_NDEBUG */ - -// Turn a number into a string. -# define ACE_ITOA(X) #X - -// Create a string of a server address with a "host:port" format. -# define ACE_SERVER_ADDRESS(H,P) H ACE_TEXT(":") P - -// A couple useful inline functions for checking whether bits are -// enabled or disabled. - -// Efficiently returns the least power of two >= X... -# define ACE_POW(X) (((X) == 0)?1:(X-=1,X|=X>>1,X|=X>>2,X|=X>>4,X|=X>>8,X|=X>>16,(++X))) -# define ACE_EVEN(NUM) (((NUM) & 1) == 0) -# define ACE_ODD(NUM) (((NUM) & 1) == 1) -# define ACE_BIT_ENABLED(WORD, BIT) (((WORD) & (BIT)) != 0) -# define ACE_BIT_DISABLED(WORD, BIT) (((WORD) & (BIT)) == 0) -# define ACE_BIT_CMP_MASK(WORD, BIT, MASK) (((WORD) & (BIT)) == MASK) -# define ACE_SET_BITS(WORD, BITS) (WORD |= (BITS)) -# define ACE_CLR_BITS(WORD, BITS) (WORD &= ~(BITS)) - -# if !defined (ACE_ENDLESS_LOOP) -# define ACE_ENDLESS_LOOP -# endif /* ! ACE_ENDLESS_LOOP */ - -# if defined (ACE_NEEDS_FUNC_DEFINITIONS) && !defined (ACE_HAS_CPP11) - // It just evaporated ;-) Not pleasant. -# define ACE_UNIMPLEMENTED_FUNC(f) -# else -# if defined (ACE_HAS_CPP11) -# define ACE_UNIMPLEMENTED_FUNC(f) f = delete; -# else -# define ACE_UNIMPLEMENTED_FUNC(f) f; -# endif -# endif /* ACE_NEEDS_FUNC_DEFINITIONS */ - -// noexcept(false) specification to specify that the operation can -// throw an exception -#if defined (ACE_HAS_CPP11) -#define ACE_NOEXCEPT_FALSE noexcept(false) -#else -#define ACE_NOEXCEPT_FALSE -#endif - -// ---------------------------------------------------------------- - -// FUZZ: disable check_for_ACE_Guard - -/* Convenient macro for testing for deadlock, as well as for detecting - * when mutexes fail. - * - * The parameters to the ACE_GUARD_XXX macros are used as follows: - * - * MUTEX - This is the type used as the template parameter for ACE_Guard - * - * OBJ - Name for the guard object. This name should not be declared - * outside the macro. - * - * LOCK - The actual lock (mutex) variable. This should be a variable - * of type MUTEX, see above. - * - * ACTION - Code segment to be run, if and only if the lock is - * acquired. - * - * REACTION - Code segment to be run, if and only if the lock is not - * acquired. - * - * RETURN - A value to be returned from the calling function, if and - * only if the lock is not acquired. - * - * @warning - * Use of ACE_GUARD() is rarely correct. ACE_GUARD() causes the - * current function to return if the lock is not acquired. Since - * merely returning (no value) almost certainly fails to handle the - * acquisition failure and almost certainly fails to communicate the - * failure to the caller for the caller to handle, ACE_GUARD() is - * almost always the wrong thing to do. The same goes for - * ACE_WRITE_GUARD() and ACE_READ_GUARD() . ACE_GUARD_REACTION() is - * better because it lets you specify error handling code. - */ -#if !defined (ACE_GUARD_ACTION) -#define ACE_GUARD_ACTION(MUTEX, OBJ, LOCK, ACTION, REACTION) \ - ACE_Guard< MUTEX > OBJ (LOCK); \ - if (OBJ.locked () != 0) { ACTION; } \ - else { REACTION; } -#endif /* !ACE_GUARD_ACTION */ -#if !defined (ACE_GUARD_REACTION) -#define ACE_GUARD_REACTION(MUTEX, OBJ, LOCK, REACTION) \ - ACE_GUARD_ACTION(MUTEX, OBJ, LOCK, ;, REACTION) -#endif /* !ACE_GUARD_REACTION */ -#if !defined (ACE_GUARD) -#define ACE_GUARD(MUTEX, OBJ, LOCK) \ - ACE_GUARD_REACTION(MUTEX, OBJ, LOCK, return) -#endif /* !ACE_GUARD */ -#if !defined (ACE_GUARD_RETURN) -#define ACE_GUARD_RETURN(MUTEX, OBJ, LOCK, RETURN) \ - ACE_GUARD_REACTION(MUTEX, OBJ, LOCK, return RETURN) -#endif /* !ACE_GUARD_RETURN */ -#if !defined (ACE_WRITE_GUARD) -# define ACE_WRITE_GUARD(MUTEX,OBJ,LOCK) \ - ACE_Write_Guard< MUTEX > OBJ (LOCK); \ - if (OBJ.locked () == 0) return; -#endif /* !ACE_WRITE_GUARD */ -#if !defined (ACE_WRITE_GUARD_RETURN) -# define ACE_WRITE_GUARD_RETURN(MUTEX,OBJ,LOCK,RETURN) \ - ACE_Write_Guard< MUTEX > OBJ (LOCK); \ - if (OBJ.locked () == 0) return RETURN; -#endif /* ACE_WRITE_GUARD_RETURN */ -#if !defined (ACE_READ_GUARD) -# define ACE_READ_GUARD(MUTEX,OBJ,LOCK) \ - ACE_Read_Guard< MUTEX > OBJ (LOCK); \ - if (OBJ.locked () == 0) return; -#endif /* !ACE_READ_GUARD */ -#if !defined (ACE_READ_GUARD_RETURN) -# define ACE_READ_GUARD_RETURN(MUTEX,OBJ,LOCK,RETURN) \ - ACE_Read_Guard< MUTEX > OBJ (LOCK); \ - if (OBJ.locked () == 0) return RETURN; -#endif /* !ACE_READ_GUARD_RETURN */ -// FUZZ: enable check_for_ACE_Guard - -// ---------------------------------------------------------------- - -#if defined(ACE_UNEXPECTED_RETURNS) - -/* Using ACE_UNEXPECTED_RETURNS is ill-advised because, in many cases, - * it fails to inform callers of the error condition. - * It exists mainly to provide back-compatibility with old, dangegrous, - * incorrect behavior. - * Code that previously used ACE_GUARD() or ACE_GUARD_RETURN() to return - * upon failure to acquire a lock can now use: - * ACE_GUARD_REACTION(..., ACE_UNEXPECTED(...)) - * The behavior of this depends on whether or not ACE_UNEXPECTED_RETURNS - * is defined. If so, it just returns upon failure (as in the original), - * which is usually dangerous because it usually fails to handle the - * error. If not, it calls std::unexpected(), which does whatever the - * std::unexpected handler does (which is to abort, by default). - */ -# define ACE_UNEXPECTED(RETVAL) \ - do { \ - return RETVAL; \ - } while (0) - -#else - -# define ACE_UNEXPECTED(RETVAL) \ - do { \ - std::unexpected(); \ - } while (0) - -#endif - -// ---------------------------------------------------------------- - -# define ACE_DES_NOFREE(POINTER,CLASS) \ - do { \ - if (POINTER) \ - { \ - (POINTER)->~CLASS (); \ - } \ - } \ - while (0) - -# define ACE_DES_ARRAY_NOFREE(POINTER,SIZE,CLASS) \ - do { \ - if (POINTER) \ - { \ - for (size_t i = 0; \ - i < SIZE; \ - ++i) \ - { \ - (&(POINTER)[i])->~CLASS (); \ - } \ - } \ - } \ - while (0) - -# define ACE_DES_FREE(POINTER,DEALLOCATOR,CLASS) \ - do { \ - if (POINTER) \ - { \ - (POINTER)->~CLASS (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) - -# define ACE_DES_FREE_THIS(DEALLOCATOR,CLASS) \ - do { \ - this->~CLASS (); \ - DEALLOCATOR (this); \ - } \ - while (0) - -# define ACE_DES_ARRAY_FREE(POINTER,SIZE,DEALLOCATOR,CLASS) \ - do { \ - if (POINTER) \ - { \ - for (size_t i = 0; \ - i < SIZE; \ - ++i) \ - { \ - (&(POINTER)[i])->~CLASS (); \ - } \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) - -# if defined (ACE_HAS_WORKING_EXPLICIT_TEMPLATE_DESTRUCTOR) -# define ACE_DES_NOFREE_TEMPLATE(POINTER,T_CLASS,T_PARAMETER) \ - do { \ - if (POINTER) \ - { \ - (POINTER)->~T_CLASS (); \ - } \ - } \ - while (0) -# define ACE_DES_ARRAY_NOFREE_TEMPLATE(POINTER,SIZE,T_CLASS,T_PARAMETER) \ - do { \ - if (POINTER) \ - { \ - for (size_t i = 0; \ - i < SIZE; \ - ++i) \ - { \ - (&(POINTER)[i])->~T_CLASS (); \ - } \ - } \ - } \ - while (0) - -#if defined (ACE_EXPLICIT_TEMPLATE_DESTRUCTOR_TAKES_ARGS) -# define ACE_DES_FREE_TEMPLATE(POINTER,DEALLOCATOR,T_CLASS,T_PARAMETER) \ - do { \ - if (POINTER) \ - { \ - (POINTER)->~T_CLASS T_PARAMETER (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -#else -# define ACE_DES_FREE_TEMPLATE(POINTER,DEALLOCATOR,T_CLASS,T_PARAMETER) \ - do { \ - if (POINTER) \ - { \ - (POINTER)->~T_CLASS (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -#endif /* defined(ACE_EXPLICIT_TEMPLATE_DESTRUCTOR_TAKES_ARGS) */ -# define ACE_DES_ARRAY_FREE_TEMPLATE(POINTER,SIZE,DEALLOCATOR,T_CLASS,T_PARAMETER) \ - do { \ - if (POINTER) \ - { \ - for (size_t i = 0; \ - i < SIZE; \ - ++i) \ - { \ - (&(POINTER)[i])->~T_CLASS (); \ - } \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -#if defined(ACE_EXPLICIT_TEMPLATE_DESTRUCTOR_TAKES_ARGS) -# define ACE_DES_FREE_TEMPLATE2(POINTER,DEALLOCATOR,T_CLASS,T_PARAM1,T_PARAM2) \ - do { \ - if (POINTER) \ - { \ - (POINTER)->~T_CLASS (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -#else -# define ACE_DES_FREE_TEMPLATE2(POINTER,DEALLOCATOR,T_CLASS,T_PARAM1,T_PARAM2) \ - do { \ - if (POINTER) \ - { \ - (POINTER)->~T_CLASS (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -#endif /* defined(ACE_EXPLICIT_TEMPLATE_DESTRUCTOR_TAKES_ARGS) */ -#if defined(ACE_EXPLICIT_TEMPLATE_DESTRUCTOR_TAKES_ARGS) -# define ACE_DES_FREE_TEMPLATE3(POINTER,DEALLOCATOR,T_CLASS,T_PARAM1,T_PARAM2,T_PARAM3) \ - do { \ - if (POINTER) \ - { \ - (POINTER)->~T_CLASS (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -#else -# define ACE_DES_FREE_TEMPLATE3(POINTER,DEALLOCATOR,T_CLASS,T_PARAM1,T_PARAM2,T_PARAM3) \ - do { \ - if (POINTER) \ - { \ - (POINTER)->~T_CLASS (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -#endif /* defined(ACE_EXPLICIT_TEMPLATE_DESTRUCTOR_TAKES_ARGS) */ -#if defined(ACE_EXPLICIT_TEMPLATE_DESTRUCTOR_TAKES_ARGS) -# define ACE_DES_FREE_TEMPLATE4(POINTER,DEALLOCATOR,T_CLASS,T_PARAM1,T_PARAM2,T_PARAM3, T_PARAM4) \ - do { \ - if (POINTER) \ - { \ - (POINTER)->~T_CLASS (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -#else -# define ACE_DES_FREE_TEMPLATE4(POINTER,DEALLOCATOR,T_CLASS,T_PARAM1,T_PARAM2,T_PARAM3, T_PARAM4) \ - do { \ - if (POINTER) \ - { \ - (POINTER)->~T_CLASS (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -#endif /* defined(ACE_EXPLICIT_TEMPLATE_DESTRUCTOR_TAKES_ARGS) */ -# define ACE_DES_ARRAY_FREE_TEMPLATE2(POINTER,SIZE,DEALLOCATOR,T_CLASS,T_PARAM1,T_PARAM2) \ - do { \ - if (POINTER) \ - { \ - for (size_t i = 0; \ - i < SIZE; \ - ++i) \ - { \ - (&(POINTER)[i])->~T_CLASS (); \ - } \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -# else /* ! ACE_HAS_WORKING_EXPLICIT_TEMPLATE_DESTRUCTOR */ -# define ACE_DES_NOFREE_TEMPLATE(POINTER,T_CLASS,T_PARAMETER) \ - do { \ - if (POINTER) \ - { \ - (POINTER)->T_CLASS T_PARAMETER::~T_CLASS (); \ - } \ - } \ - while (0) -# define ACE_DES_ARRAY_NOFREE_TEMPLATE(POINTER,SIZE,T_CLASS,T_PARAMETER) \ - do { \ - if (POINTER) \ - { \ - for (size_t i = 0; \ - i < SIZE; \ - ++i) \ - { \ - (POINTER)[i].T_CLASS T_PARAMETER::~T_CLASS (); \ - } \ - } \ - } \ - while (0) -# define ACE_DES_FREE_TEMPLATE(POINTER,DEALLOCATOR,T_CLASS,T_PARAMETER) \ - do { \ - if (POINTER) \ - { \ - POINTER->T_CLASS T_PARAMETER::~T_CLASS (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -# define ACE_DES_ARRAY_FREE_TEMPLATE(POINTER,SIZE,DEALLOCATOR,T_CLASS,T_PARAMETER) \ - do { \ - if (POINTER) \ - { \ - for (size_t i = 0; \ - i < SIZE; \ - ++i) \ - { \ - POINTER[i].T_CLASS T_PARAMETER::~T_CLASS (); \ - } \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -# define ACE_DES_FREE_TEMPLATE2(POINTER,DEALLOCATOR,T_CLASS,T_PARAM1,T_PARAM2) \ - do { \ - if (POINTER) \ - { \ - POINTER->T_CLASS ::~T_CLASS (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -# define ACE_DES_FREE_TEMPLATE3(POINTER,DEALLOCATOR,T_CLASS,T_PARAM1,T_PARAM2,T_PARAM3) \ - do { \ - if (POINTER) \ - { \ - POINTER->T_CLASS ::~T_CLASS (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -# define ACE_DES_FREE_TEMPLATE4(POINTER,DEALLOCATOR,T_CLASS,T_PARAM1,T_PARAM2,T_PARAM3,T_PARAM4) \ - do { \ - if (POINTER) \ - { \ - POINTER->T_CLASS ::~T_CLASS (); \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -# define ACE_DES_ARRAY_FREE_TEMPLATE2(POINTER,SIZE,DEALLOCATOR,T_CLASS,T_PARAM1,T_PARAM2) \ - do { \ - if (POINTER) \ - { \ - for (size_t i = 0; \ - i < SIZE; \ - ++i) \ - { \ - POINTER[i].T_CLASS ::~T_CLASS (); \ - } \ - DEALLOCATOR (POINTER); \ - } \ - } \ - while (0) -# endif /* defined ! ACE_HAS_WORKING_EXPLICIT_TEMPLATE_DESTRUCTOR */ - - -/*******************************************************************/ - -/// Service Objects, i.e., objects dynamically loaded via the service -/// configurator, must provide a destructor function with the -/// following prototype to perform object cleanup. -typedef void (*ACE_Service_Object_Exterminator)(void *); - -/** @name Service Configurator macros - * - * The following macros are used to define helper objects used in - * ACE's Service Configurator framework, which is described in - * Chapter 5 of C++NPv2 . This - * framework implements the Component Configurator pattern, which is - * described in Chapter 2 of POSA2 . - * The intent of this pattern is to allow developers to dynamically - * load and configure services into a system. With a little help from - * this macros statically linked services can also be dynamically - * configured. - * - * More details about this component are available in the documentation - * of the ACE_Service_Configurator class and also - * ACE_Dynamic_Service. - * - * Notice that in all the macros the SERVICE_CLASS parameter must be - * the name of a class derived from ACE_Service_Object. - */ -//@{ -/// Declare a the data structure required to register a statically -/// linked service into the service configurator. -/** - * The macro should be used in the header file where the service is - * declared, its only argument is usually the name of the class that - * implements the service. - * - * @param SERVICE_CLASS The name of the class implementing the - * service. - */ -# define ACE_STATIC_SVC_DECLARE(SERVICE_CLASS) \ -extern ACE_Static_Svc_Descriptor ace_svc_desc_##SERVICE_CLASS ; - -/// As ACE_STATIC_SVC_DECLARE, but using an export macro for NT -/// compilers. -/** - * NT compilers require the use of explicit directives to export and - * import symbols from a DLL. If you need to define a service in a - * dynamic library you should use this version instead. - * Normally ACE uses a macro to inject the correct export/import - * directives on NT. Naturally it also the macro expands to a blank - * on platforms that do not require such directives. - * The first argument (EXPORT_NAME) is the prefix for this export - * macro, the full name is formed by appending _Export. - * ACE provides tools to generate header files that define the macro - * correctly on all platforms, please see - * $ACE_ROOT/bin/generate_export_file.pl - * - * @param EXPORT_NAME The export macro name prefix. - * @param SERVICE_CLASS The name of the class implementing the service. - */ -#define ACE_STATIC_SVC_DECLARE_EXPORT(EXPORT_NAME,SERVICE_CLASS) \ -extern EXPORT_NAME##_Export ACE_Static_Svc_Descriptor ace_svc_desc_##SERVICE_CLASS; - -/// Define the data structure used to register a statically linked -/// service into the Service Configurator. -/** - * The service configurator requires several arguments to build and - * control an statically linked service, including its name, the - * factory function used to construct the service, and some flags. - * All those parameters are configured in a single structure, an - * instance of this structure is statically initialized using the - * following macro. - * - * @param SERVICE_CLASS The name of the class that implements the - * service, must be derived (directly or indirectly) from - * ACE_Service_Object. - * @param NAME The name for this service, this name is used by the - * service configurator to match configuration options provided in - * the svc.conf file. - * @param TYPE The type of object. Objects can be streams or service - * objects. Please read the ACE_Service_Configurator and ASX - * documentation for more details. - * @param FN The name of the factory function, usually the - * ACE_SVC_NAME macro can be used to generate the name. The - * factory function is often defined using ACE_FACTORY_DECLARE and - * ACE_FACTORY_DEFINE. - * @param FLAGS Flags to control the ownership and lifecycle of the - * object. Please read the ACE_Service_Configurator documentation - * for more details. - * @param ACTIVE If not zero then a thread will be dedicate to the - * service. Please read the ACE_Service_Configurator documentation - * for more details. - */ -# define ACE_STATIC_SVC_DEFINE(SERVICE_CLASS, NAME, TYPE, FN, FLAGS, ACTIVE) \ -ACE_Static_Svc_Descriptor ace_svc_desc_##SERVICE_CLASS = { NAME, TYPE, FN, FLAGS, ACTIVE }; - -/// Automatically register a service with the service configurator -/** - * In some applications the services must be automatically registered - * with the service configurator, before main() starts. - * The ACE_STATIC_SVC_REQUIRE macro defines a class whose constructor - * register the service, it also defines a static instance of that - * class to ensure that the service is registered before main. - * - * On platforms that lack adequate support for static C++ objects the - * macro ACE_STATIC_SVC_REGISTER can be used to explicitly register - * the service. - * - * @todo One class per-Service_Object seems wasteful. It should be - * possible to define a single class and re-use it for all the - * service objects, just by passing the Service_Descriptor as an - * argument to the constructor. - */ -#if defined(ACE_LACKS_STATIC_CONSTRUCTORS) -# define ACE_STATIC_SVC_REQUIRE(SERVICE_CLASS)\ -class ACE_Static_Svc_##SERVICE_CLASS {\ -public:\ - ACE_Static_Svc_##SERVICE_CLASS() { \ - ACE_Service_Config::insert (\ - &ace_svc_desc_##SERVICE_CLASS); \ - } \ -}; -#define ACE_STATIC_SVC_REGISTER(SERVICE_CLASS)\ -ACE_Static_Svc_##SERVICE_CLASS ace_static_svc_##SERVICE_CLASS - -#else /* !ACE_LACKS_STATIC_CONSTRUCTORS */ - -# define ACE_STATIC_SVC_REQUIRE(SERVICE_CLASS)\ -class ACE_Static_Svc_##SERVICE_CLASS {\ -public:\ - ACE_Static_Svc_##SERVICE_CLASS() { \ - ACE_Service_Config::insert (\ - &ace_svc_desc_##SERVICE_CLASS); \ - } \ -};\ -static ACE_Static_Svc_##SERVICE_CLASS ace_static_svc_##SERVICE_CLASS; -#define ACE_STATIC_SVC_REGISTER(SERVICE_CLASS) do {} while (0) - -#endif /* !ACE_LACKS_STATIC_CONSTRUCTORS */ - -// Preprocessor symbols will not be expanded if they are -// concatenated. Force the preprocessor to expand them during the -// argument prescan by calling a macro that itself calls another that -// performs the actual concatenation. -#define ACE_PREPROC_CONCATENATE_IMPL(A,B) A ## B -#define ACE_PREPROC_CONCATENATE(A,B) ACE_PREPROC_CONCATENATE_IMPL(A,B) - -#if defined (ACE_HAS_VERSIONED_NAMESPACE) && ACE_HAS_VERSIONED_NAMESPACE == 1 -// Preprocessor symbols will not be expanded if they are -// concatenated. Force the preprocessor to expand them during the -// argument prescan by calling a macro that itself calls another that -// performs the actual concatenation. -# define ACE_MAKE_SVC_CONFIG_FUNCTION_NAME(PREFIX,VERSIONED_NAMESPACE,SERVICE_CLASS) PREFIX ## _ ## VERSIONED_NAMESPACE ## _ ## SERVICE_CLASS -#else -# define ACE_MAKE_SVC_CONFIG_FUNCTION_NAME(PREFIX,VERSIONED_NAMESPACE,SERVICE_CLASS) PREFIX ## _ ## SERVICE_CLASS -#endif /* ACE_HAS_VERSIONED_NAMESPACE == 1 */ - -#define ACE_MAKE_SVC_CONFIG_FACTORY_NAME(VERSIONED_NAMESPACE,SERVICE_CLASS) ACE_MAKE_SVC_CONFIG_FUNCTION_NAME(_make,VERSIONED_NAMESPACE,SERVICE_CLASS) -#define ACE_MAKE_SVC_CONFIG_GOBBLER_NAME(VERSIONED_NAMESPACE,SERVICE_CLASS) ACE_MAKE_SVC_CONFIG_FUNCTION_NAME(_gobble,VERSIONED_NAMESPACE,SERVICE_CLASS) - - -/// Declare the factory method used to create dynamically loadable -/// services. -/** - * Once the service implementation is dynamically loaded the Service - * Configurator uses a factory method to create the object. - * This macro declares such a factory function with the proper - * interface and export macros. - * Normally used in the header file that declares the service - * implementation. - * - * @param CLS must match the prefix of the export macro used for this - * service. - * @param SERVICE_CLASS must match the name of the class that - * implements the service. - */ -# define ACE_FACTORY_DECLARE(CLS,SERVICE_CLASS) \ -extern "C" CLS##_Export ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object * \ -ACE_MAKE_SVC_CONFIG_FACTORY_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS) (ACE_Service_Object_Exterminator *); - -/// Define the factory method (and destructor) for a dynamically -/// loadable service. -/** - * Use with arguments matching ACE_FACTORY_DECLARE. - * Normally used in the .cpp file that defines the service - * implementation. - * - * This macro defines both the factory method and the function used to - * cleanup the service object. - * - * If this macro is used to define a factory function that need not be - * exported (for example, in a static service situation), CLS can be - * specified as ACE_Local_Service. - */ -# define ACE_Local_Service_Export - -#if defined (ACE_OPENVMS) -# define ACE_PREPROC_STRINGIFY(A) #A -# define ACE_MAKE_SVC_REGISTRAR_ARG(A) ACE_PREPROC_STRINGIFY(A), (void*)&A -# define ACE_FACTORY_DEFINE(CLS,SERVICE_CLASS) \ -void ACE_MAKE_SVC_CONFIG_GOBBLER_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS) (void *p) { \ - ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object * _p = \ - static_cast< ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object *> (p); \ - ACE_ASSERT (_p != 0); \ - delete _p; } \ -extern "C" CLS##_Export ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object *\ -ACE_MAKE_SVC_CONFIG_FACTORY_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS) (ACE_Service_Object_Exterminator *gobbler) \ -{ \ - ACE_TRACE (#SERVICE_CLASS); \ - if (gobbler != 0) \ - *gobbler = (ACE_Service_Object_Exterminator) ACE_MAKE_SVC_CONFIG_GOBBLER_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS); \ - return new SERVICE_CLASS; \ -} \ -ACE_Dynamic_Svc_Registrar ace_svc_reg_##SERVICE_CLASS \ - (ACE_MAKE_SVC_REGISTRAR_ARG(ACE_MAKE_SVC_CONFIG_FACTORY_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS))); -#else -# define ACE_FACTORY_DEFINE(CLS,SERVICE_CLASS) \ -void ACE_MAKE_SVC_CONFIG_GOBBLER_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS) (void *p) { \ - ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object * _p = \ - static_cast< ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object *> (p); \ - ACE_ASSERT (_p != 0); \ - delete _p; } \ -extern "C" CLS##_Export ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object *\ -ACE_MAKE_SVC_CONFIG_FACTORY_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS) (ACE_Service_Object_Exterminator *gobbler) \ -{ \ - ACE_TRACE (#SERVICE_CLASS); \ - if (gobbler != 0) \ - *gobbler = (ACE_Service_Object_Exterminator) ACE_MAKE_SVC_CONFIG_GOBBLER_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS); \ - return new SERVICE_CLASS; \ -} -#endif - -/** - * For service classes scoped within namespaces, use this macro in - * place of ACE_FACTORY_DEFINE. The third argument in this case is - * the fully scoped name of the class as it is to be - * instantiated. For example, given: - * namespace ACE - * { - * namespace Foo - * { - * class Bar : public ACE_Service_Object - * {}; - * }; - * }; - * - * ACE_FACTORY_DECLARE(ACE,ACE_Foo_Bar) - * - * you would then use: - * - * ACE_FACTORY_NAMESPACE_DEFINE(ACE,ACE_Foo_Bar,ACE::Foo::Bar) - * - * Note that in this example, the ACE_FACTORY_DECLARE is done outside - * the namespace scope. Then, the SERVICE_CLASS name is the same as - * the fully scoped class name, but with '::' replaced with '_'. Doing - * this will ensure unique generated signatures for the various C - * style functions. - */ -#if defined (ACE_OPENVMS) -# define ACE_PREPROC_STRINGIFY(A) #A -# define ACE_MAKE_SVC_REGISTRAR_ARG(A) ACE_PREPROC_STRINGIFY(A), (void*)&A -# define ACE_FACTORY_NAMESPACE_DEFINE(CLS,SERVICE_CLASS,NAMESPACE_CLASS) \ -void ACE_MAKE_SVC_CONFIG_GOBBLER_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS) (void *p) { \ - ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object * _p = \ - static_cast< ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object *> (p); \ - ACE_ASSERT (_p != 0); \ - delete _p; } \ -extern "C" CLS##_Export ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object *\ -ACE_MAKE_SVC_CONFIG_FACTORY_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS) (ACE_Service_Object_Exterminator *gobbler) \ -{ \ - ACE_TRACE (#SERVICE_CLASS); \ - if (gobbler != 0) \ - *gobbler = (ACE_Service_Object_Exterminator) ACE_MAKE_SVC_CONFIG_GOBBLER_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS); \ - return new NAMESPACE_CLASS; \ -} \ -ACE_Dynamic_Svc_Registrar ace_svc_reg_##SERVICE_CLASS \ - (ACE_MAKE_SVC_REGISTRAR_ARG(ACE_MAKE_SVC_CONFIG_FACTORY_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS))); -#else -# define ACE_FACTORY_NAMESPACE_DEFINE(CLS,SERVICE_CLASS,NAMESPACE_CLASS) \ -void ACE_MAKE_SVC_CONFIG_GOBBLER_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS) (void *p) { \ - ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object * _p = \ - static_cast< ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object *> (p); \ - ACE_ASSERT (_p != 0); \ - delete _p; } \ -extern "C" CLS##_Export ACE_VERSIONED_NAMESPACE_NAME::ACE_Service_Object *\ -ACE_MAKE_SVC_CONFIG_FACTORY_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS) (ACE_Service_Object_Exterminator *gobbler) \ -{ \ - ACE_TRACE (#SERVICE_CLASS); \ - if (gobbler != 0) \ - *gobbler = (ACE_Service_Object_Exterminator) ACE_MAKE_SVC_CONFIG_GOBBLER_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS); \ - return new NAMESPACE_CLASS; \ -} -#endif - -/// The canonical name for a service factory method -# define ACE_SVC_NAME(SERVICE_CLASS) ACE_MAKE_SVC_CONFIG_FACTORY_NAME(ACE_VERSIONED_NAMESPACE_NAME,SERVICE_CLASS) - -/// The canonical way to invoke (i.e. construct) a service factory -/// method. -#define ACE_SVC_INVOKE(SERVICE_CLASS) ACE_SVC_NAME(SERVICE_CLASS) (0) - -//@} - -/** @name Helper macros for services defined in the netsvcs library. - * - * The ACE services defined in netsvcs use this helper macros for - * simplicity. - */ -//@{ -# define ACE_SVC_FACTORY_DECLARE(X) ACE_FACTORY_DECLARE (ACE_Svc, X) -# define ACE_SVC_FACTORY_DEFINE(X) ACE_FACTORY_DEFINE (ACE_Svc, X) -//@} - -#if defined (ACE_WIN32) -// These are used in SPIPE_Acceptor/Connector, but are ignored at runtime. -# if defined (ACE_HAS_WINCE) -# if !defined (PIPE_TYPE_MESSAGE) -# define PIPE_TYPE_MESSAGE 0 -# endif -# if !defined (PIPE_READMODE_MESSAGE) -# define PIPE_READMODE_MESSAGE 0 -# endif -# if !defined (PIPE_WAIT) -# define PIPE_WAIT 0 -# endif -# endif /* ACE_HAS_WINCE */ -#else /* !ACE_WIN32 */ -// Add some typedefs and macros to enhance Win32 conformance... -# if !defined (LPSECURITY_ATTRIBUTES) -# define LPSECURITY_ATTRIBUTES int -# endif /* !defined LPSECURITY_ATTRIBUTES */ -# if !defined (GENERIC_READ) -# define GENERIC_READ 0 -# endif /* !defined GENERIC_READ */ -# if !defined (FILE_SHARE_READ) -# define FILE_SHARE_READ 0 -# endif /* !defined FILE_SHARE_READ */ -# if !defined (OPEN_EXISTING) -# define OPEN_EXISTING 0 -# endif /* !defined OPEN_EXISTING */ -# if !defined (FILE_ATTRIBUTE_NORMAL) -# define FILE_ATTRIBUTE_NORMAL 0 -# endif /* !defined FILE_ATTRIBUTE_NORMAL */ -# if !defined (MAXIMUM_WAIT_OBJECTS) -# define MAXIMUM_WAIT_OBJECTS 0 -# endif /* !defined MAXIMUM_WAIT_OBJECTS */ -# if !defined (FILE_FLAG_OVERLAPPED) -# define FILE_FLAG_OVERLAPPED 0 -# endif /* !defined FILE_FLAG_OVERLAPPED */ -# if !defined (FILE_FLAG_SEQUENTIAL_SCAN) -# define FILE_FLAG_SEQUENTIAL_SCAN 0 -# endif /* FILE_FLAG_SEQUENTIAL_SCAN */ -# if !defined(FILE_FLAG_WRITE_THROUGH) -# define FILE_FLAG_WRITE_THROUGH 0 -# endif /* !defined FILE_FLAG_WRITE_THROUGH */ -# if !defined(PIPE_WAIT) -# define PIPE_WAIT 0 -# endif /* !defined PIPE_WAIT */ -# if !defined(PIPE_NOWAIT) -# define PIPE_NOWAIT 0 -# endif /* !defined PIPE_WAIT */ -# if !defined(PIPE_READMODE_BYTE) -# define PIPE_READMODE_BYTE 0 -# endif /* !defined PIPE_READMODE_BYTE */ -# if !defined(PIPE_READMODE_MESSAGE) -# define PIPE_READMODE_MESSAGE 0 -# endif /* !defined PIPE_READMODE_MESSAGE */ -# if !defined(PIPE_TYPE_BYTE) -# define PIPE_TYPE_BYTE 0 -# endif /* !defined PIPE_TYPE_BYTE */ -# if !defined(PIPE_TYPE_MESSAGE) -# define PIPE_TYPE_MESSAGE 0 -# endif /* !defined PIPE_TYPE_MESSAGE */ -#endif /* ACE_WIN32 */ - - -// Some useful abstractions for expressions involving -// ACE_Allocator.malloc (). The difference between ACE_NEW_MALLOC* -// with ACE_ALLOCATOR* is that they call constructors also. - -#include "ace/OS_Errno.h" /* Need errno and ENOMEM */ - -# define ACE_ALLOCATOR_RETURN(POINTER,ALLOCATOR,RET_VAL) \ - do { POINTER = ALLOCATOR; \ - if (POINTER == 0) { errno = ENOMEM; return RET_VAL; } \ - } while (0) -# define ACE_ALLOCATOR(POINTER,ALLOCATOR) \ - do { POINTER = ALLOCATOR; \ - if (POINTER == 0) { errno = ENOMEM; return; } \ - } while (0) -# define ACE_ALLOCATOR_NORETURN(POINTER,ALLOCATOR) \ - do { POINTER = ALLOCATOR; \ - if (POINTER == 0) { errno = ENOMEM; } \ - } while (0) - -# define ACE_NEW_MALLOC_RETURN(POINTER,ALLOCATOR,CONSTRUCTOR,RET_VAL) \ - do { POINTER = ALLOCATOR; \ - if (POINTER == 0) { errno = ENOMEM; return RET_VAL;} \ - else { (void) new (POINTER) CONSTRUCTOR; } \ - } while (0) -# define ACE_NEW_MALLOC(POINTER,ALLOCATOR,CONSTRUCTOR) \ - do { POINTER = ALLOCATOR; \ - if (POINTER == 0) { errno = ENOMEM; return;} \ - else { (void) new (POINTER) CONSTRUCTOR; } \ - } while (0) -# define ACE_NEW_MALLOC_NORETURN(POINTER,ALLOCATOR,CONSTRUCTOR) \ - do { POINTER = ALLOCATOR; \ - if (POINTER == 0) { errno = ENOMEM;} \ - else { (void) new (POINTER) CONSTRUCTOR; } \ - } while (0) - -/* ACE_Metrics */ -#if defined ACE_LACKS_ARRAY_PLACEMENT_NEW -# define ACE_NEW_MALLOC_ARRAY_RETURN(POINTER,ALLOCATOR,CONSTRUCTOR,COUNT,RET_VAL) \ - do { POINTER = ALLOCATOR; \ - if (POINTER == 0) { errno = ENOMEM; return RET_VAL;} \ - else { for (u_int i = 0; i < COUNT; ++i) \ - {(void) new (POINTER) CONSTRUCTOR; ++POINTER;} \ - POINTER -= COUNT;} \ - } while (0) -# define ACE_NEW_MALLOC_ARRAY(POINTER,ALLOCATOR,CONSTRUCTOR,COUNT) \ - do { POINTER = ALLOCATOR; \ - if (POINTER == 0) { errno = ENOMEM; return;} \ - else { for (u_int i = 0; i < COUNT; ++i) \ - {(void) new (POINTER) CONSTRUCTOR; ++POINTER;} \ - POINTER -= COUNT;} \ - } while (0) -#else /* ! defined ACE_LACKS_ARRAY_PLACEMENT_NEW */ -# define ACE_NEW_MALLOC_ARRAY_RETURN(POINTER,ALLOCATOR,CONSTRUCTOR,COUNT,RET_VAL) \ - do { POINTER = ALLOCATOR; \ - if (POINTER == 0) { errno = ENOMEM; return RET_VAL;} \ - else { (void) new (POINTER) CONSTRUCTOR [COUNT]; } \ - } while (0) -# define ACE_NEW_MALLOC_ARRAY(POINTER,ALLOCATOR,CONSTRUCTOR,COUNT) \ - do { POINTER = ALLOCATOR; \ - if (POINTER == 0) { errno = ENOMEM; return;} \ - else { (void) new (POINTER) CONSTRUCTOR [COUNT]; } \ - } while (0) -#endif /* defined ACE_LACKS_ARRAY_PLACEMENT_NEW */ - -// This is being placed here temporarily to help stabilize the builds, but will -// be moved out along with the above macros as part of the subsetting. dhinton -#if !defined (ACE_LACKS_NEW_H) -# if defined (ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB) -# include /**/ -# else -# include /**/ -# endif /* ACE_USES_STD_NAMESPACE_FOR_STDCPP_LIB */ -#endif /* ! ACE_LACKS_NEW_H */ - -# define ACE_NOOP(x) - -#if defined (ACE_WIN32) && defined (ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS) -# define ACE_SEH_TRY __try -# define ACE_SEH_EXCEPT(X) __except(X) -# define ACE_SEH_FINALLY __finally -#else /* !ACE_WIN32 */ -# define ACE_SEH_TRY if (1) -# define ACE_SEH_EXCEPT(X) while (0) -# define ACE_SEH_FINALLY if (1) -#endif /* ACE_WIN32 */ - -// Handle ACE_Message_Queue. -# define ACE_SYNCH_DECL typename _ACE_SYNCH -# define ACE_SYNCH_USE _ACE_SYNCH -# define ACE_SYNCH_MUTEX_T typename _ACE_SYNCH::MUTEX -# define ACE_SYNCH_CONDITION_T typename _ACE_SYNCH::CONDITION -# define ACE_SYNCH_SEMAPHORE_T typename _ACE_SYNCH::SEMAPHORE - -// Handle ACE_Malloc* -# define ACE_MEM_POOL_1 typename _ACE_MEM_POOL -# define ACE_MEM_POOL_2 _ACE_MEM_POOL -# define ACE_MEM_POOL _ACE_MEM_POOL -# define ACE_MEM_POOL_OPTIONS typename _ACE_MEM_POOL::OPTIONS - -// @deprecated These macros are not longer used in ACE_Svc_Handler. -// Handle ACE_Svc_Handler -# define ACE_PEER_STREAM_1 typename _ACE_PEER_STREAM -# define ACE_PEER_STREAM_2 _ACE_PEER_STREAM -# define ACE_PEER_STREAM _ACE_PEER_STREAM -# define ACE_PEER_STREAM_ADDR typename _ACE_PEER_STREAM::PEER_ADDR - -// @deprecated These macros are not longer used in ACE_Acceptor. -// Handle ACE_Acceptor -# define ACE_PEER_ACCEPTOR_1 typename _ACE_PEER_ACCEPTOR -# define ACE_PEER_ACCEPTOR_2 _ACE_PEER_ACCEPTOR -# define ACE_PEER_ACCEPTOR _ACE_PEER_ACCEPTOR -# define ACE_PEER_ACCEPTOR_ADDR typename _ACE_PEER_ACCEPTOR::PEER_ADDR - -// @deprecated These macros are not longer used in ACE_Connector. -// Handle ACE_Connector -# define ACE_PEER_CONNECTOR_1 typename _ACE_PEER_CONNECTOR -# define ACE_PEER_CONNECTOR_2 _ACE_PEER_CONNECTOR -# define ACE_PEER_CONNECTOR _ACE_PEER_CONNECTOR -# define ACE_PEER_CONNECTOR_ADDR typename ACE_PEER_CONNECTOR::PEER_ADDR -# define ACE_PEER_CONNECTOR_ADDR_ANY ACE_PEER_ADDR_TYPEDEF::sap_any - -// Handle ACE_SOCK_* -# define ACE_SOCK_ACCEPTOR ACE_SOCK_Acceptor -# define ACE_SOCK_CONNECTOR ACE_SOCK_Connector -# define ACE_SOCK_STREAM ACE_SOCK_Stream -# define ACE_SOCK_DGRAM ACE_SOCK_Dgram -# define ACE_SOCK_DGRAM_BCAST ACE_SOCK_Dgram_Bcast -# define ACE_SOCK_DGRAM_MCAST ACE_SOCK_Dgram_Mcast - -// Handle ACE_SOCK_SEQPACK_* -# define ACE_SOCK_SEQPACK_ACCEPTOR ACE_SOCK_SEQPACK_Acceptor -# define ACE_SOCK_SEQPACK_CONNECTOR ACE_SOCK_SEQPACK_Connector -# define ACE_SOCK_SEQPACK_ASSOCIATION ACE_SOCK_SEQPACK_Association - -// Handle ACE_MEM_* -# define ACE_MEM_ACCEPTOR ACE_MEM_Acceptor -# define ACE_MEM_CONNECTOR ACE_MEM_Connector -# define ACE_MEM_STREAM ACE_MEM_Stream - -// Handle ACE_LSOCK_* -# define ACE_LSOCK_ACCEPTOR ACE_LSOCK_Acceptor -# define ACE_LSOCK_CONNECTOR ACE_LSOCK_Connector -# define ACE_LSOCK_STREAM ACE_LSOCK_Stream - -// Handle ACE_TLI_* -# define ACE_TLI_ACCEPTOR ACE_TLI_Acceptor -# define ACE_TLI_CONNECTOR ACE_TLI_Connector -# define ACE_TLI_STREAM ACE_TLI_Stream - -// Handle ACE_SPIPE_* -# define ACE_SPIPE_ACCEPTOR ACE_SPIPE_Acceptor -# define ACE_SPIPE_CONNECTOR ACE_SPIPE_Connector -# define ACE_SPIPE_STREAM ACE_SPIPE_Stream - -// Handle ACE_UPIPE_* -# define ACE_UPIPE_ACCEPTOR ACE_UPIPE_Acceptor -# define ACE_UPIPE_CONNECTOR ACE_UPIPE_Connector -# define ACE_UPIPE_STREAM ACE_UPIPE_Stream - -// Handle ACE_*_Memory_Pool. -# define ACE_MMAP_MEMORY_POOL ACE_MMAP_Memory_Pool -# define ACE_LITE_MMAP_MEMORY_POOL ACE_Lite_MMAP_Memory_Pool -# define ACE_SBRK_MEMORY_POOL ACE_Sbrk_Memory_Pool -# define ACE_SHARED_MEMORY_POOL ACE_Shared_Memory_Pool -# define ACE_LOCAL_MEMORY_POOL ACE_Local_Memory_Pool -# define ACE_PAGEFILE_MEMORY_POOL ACE_Pagefile_Memory_Pool - -#include /**/ "ace/post.h" - -#endif /*ACE_GLOBAL_MACROS_H*/ diff --git a/deps/acelite/ace/Guard_T.cpp b/deps/acelite/ace/Guard_T.cpp deleted file mode 100644 index dd4f9a2b9..000000000 --- a/deps/acelite/ace/Guard_T.cpp +++ /dev/null @@ -1,60 +0,0 @@ -#ifndef ACE_GUARD_T_CPP -#define ACE_GUARD_T_CPP - -// FUZZ: disable check_for_ACE_Guard -#include "ace/Guard_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (__ACE_INLINE__) -#include "ace/Guard_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_HAS_DUMP) -# include "ace/Log_Category.h" -#endif /* ACE_HAS_DUMP */ - -// **************************************************************** - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// ACE_ALLOC_HOOK_DEFINE(ACE_Guard) - -template void -ACE_Guard::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Guard::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("mutex_ = %x\n"), this->lock_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("owner_ = %d\n"), this->owner_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -// ACE_ALLOC_HOOK_DEFINE(ACE_Write_Guard) - -template void -ACE_Write_Guard::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Write_Guard::dump"); - ACE_Guard::dump (); -#endif /* ACE_HAS_DUMP */ -} - -// ACE_ALLOC_HOOK_DEFINE(ACE_Read_Guard) - -template void -ACE_Read_Guard::dump (void) const -{ -// ACE_TRACE ("ACE_Read_Guard::dump"); - ACE_Guard::dump (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_GUARD_T_CPP */ diff --git a/deps/acelite/ace/Guard_T.h b/deps/acelite/ace/Guard_T.h deleted file mode 100644 index 03fa8dba9..000000000 --- a/deps/acelite/ace/Guard_T.h +++ /dev/null @@ -1,394 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Guard_T.h - * - * Moved from Synch.h. - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_GUARD_T_H -#define ACE_GUARD_T_H -#include /**/ "ace/pre.h" - -#include "ace/Lock.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Global_Macros.h" -#include "ace/OS_NS_Thread.h" - -// FUZZ: disable check_for_ACE_Guard - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Guard - * - * @brief This data structure is meant to be used within a method or - * function... It performs automatic acquisition and release of - * a parameterized synchronization object ACE_LOCK. - * - * The ACE_LOCK class given as an actual parameter must provide, at - * the very least the acquire(), tryacquire(), release(), and - * remove() methods. - * - * @warning A successfully constructed ACE_Guard does NOT mean that the - * lock was acquired! It is the caller's responsibility, after - * constructing an ACE_Guard, to check whether the lock was successfully - * acquired. Code like this is dangerous: - * { - * ACE_Guard g(lock); - * ... perform critical operation requiring lock to be held ... - * } - * Instead, one must do something like this: - * { - * ACE_Guard g(lock); - * if (! g.locked()) - * { - * ... handle error ... - * } - * else - * { - * ... perform critical operation requiring lock to be held ... - * } - * } - * The ACE_GUARD_RETURN() and ACE_GUARD_REACTION() macros are designed to - * to help with this. - */ -template -class ACE_Guard -{ -public: - ACE_Guard (ACE_LOCK &l); - - /// Implicitly and automatically acquire (or try to acquire) the - /// lock. If @a block is non-0 then acquire() the ACE_LOCK, else - /// tryacquire() it. - ACE_Guard (ACE_LOCK &l, bool block); - - /// Initialize the guard without implicitly acquiring the lock. The - /// @a become_owner parameter indicates whether the guard should release - /// the lock implicitly on destruction. The @a block parameter is - /// ignored and is used here to disambiguate with the preceding - /// constructor. - ACE_Guard (ACE_LOCK &l, bool block, int become_owner); - - /// Implicitly release the lock. - ~ACE_Guard (void); - - // = Lock accessors. - - /// Explicitly acquire the lock. - int acquire (void); - - /// Conditionally acquire the lock (i.e., won't block). - int tryacquire (void); - - /// Explicitly release the lock, but only if it is held! - int release (void); - - /// Relinquish ownership of the lock so that it is not released - /// implicitly in the destructor. - void disown (void); - - // = Utility methods. - /// true if locked, false if couldn't acquire the lock - /// (errno will contain the reason for this). - bool locked (void) const; - - /// Explicitly remove the lock. - int remove (void); - - /// Dump the state of an object. - void dump (void) const; - - // ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. - -protected: - - /// Helper, meant for subclass only. - ACE_Guard (ACE_LOCK *lock): lock_ (lock), owner_ (0) {} - - /// Pointer to the ACE_LOCK we're guarding. - ACE_LOCK *lock_; - - /// Keeps track of whether we acquired the lock or failed. - int owner_; - -private: - // = Prevent assignment and initialization. - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Guard &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Guard (const ACE_Guard &)) -}; - -/** - * @class ACE_Write_Guard - * - * @brief This class is similar to class ACE_Guard, though it - * acquires/releases a write lock automatically (naturally, the - * it is instantiated with must support the appropriate - * API). - * - * @warning See important "WARNING" in comments at top of ACE_Guard. - */ -template -class ACE_Write_Guard : public ACE_Guard -{ -public: - /// Implicitly and automatically acquire a write lock. - ACE_Write_Guard (ACE_LOCK &m); - - /// Implicitly and automatically acquire (or try to acquire) a write - /// lock. - ACE_Write_Guard (ACE_LOCK &m, bool block); - - // = Lock accessors. - - /// Explicitly acquire the write lock. - int acquire_write (void); - - /// Explicitly acquire the write lock. - int acquire (void); - - /// Conditionally acquire the write lock (i.e., won't block). - int tryacquire_write (void); - - /// Conditionally acquire the write lock (i.e., won't block). - int tryacquire (void); - - // = Utility methods. - - /// Dump the state of an object. - void dump (void) const; - - // ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -}; - -/** - * @class ACE_Read_Guard - * - * @brief This class is similar to class ACE_Guard, though it - * acquires/releases a read lock automatically (naturally, the - * it is instantiated with must support the appropriate - * API). - * - * @warning See important "WARNING" in comments at top of ACE_Guard. - */ -template -class ACE_Read_Guard : public ACE_Guard -{ -public: - /// Implicitly and automatically acquire a read lock. - ACE_Read_Guard (ACE_LOCK& m); - - /// Implicitly and automatically acquire (or try to acquire) a read - /// lock. - ACE_Read_Guard (ACE_LOCK &m, bool block); - - // = Lock accessors. - - /// Explicitly acquire the read lock. - int acquire_read (void); - - /// Explicitly acquire the read lock. - int acquire (void); - - /// Conditionally acquire the read lock (i.e., won't block). - int tryacquire_read (void); - - /// Conditionally acquire the read lock (i.e., won't block). - int tryacquire (void); - - // = Utility methods. - - /// Dump the state of an object. - void dump (void) const; - - // ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -}; - -#if !(defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))) - -#define ACE_TSS_Guard ACE_Guard -#define ACE_TSS_Write_GUARD ACE_Write_Guard -#define ACE_TSS_Read_GUARD ACE_Read_Guard - -#else - /* ACE platform supports some form of threading and - thread-specific storage. */ - -/** - * @class ACE_TSS_Guard - * - * @brief This data structure is meant to be used within a method or - * function... It performs automatic aquisition and release of - * a synchronization object. Moreover, it ensures that the lock - * is released even if a thread exits via ! - */ -template -class ACE_TSS_Guard -{ -public: - /// Implicitly and automatically acquire the thread-specific lock. - ACE_TSS_Guard (ACE_LOCK &lock, bool block = true); - - /// Implicitly release the thread-specific lock. - ~ACE_TSS_Guard (void); - - // = Lock accessors. - - /// Explicitly acquire the thread-specific lock. - int acquire (void); - - /// Conditionally acquire the thread-specific lock (i.e., won't - /// block). - int tryacquire (void); - - /// Explicitly release the thread-specific lock. - int release (void); - - // = Utility methods. - /// Explicitly release the thread-specific lock. - int remove (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Helper, meant for subclass only. - ACE_TSS_Guard (void); - - /// Initialize the key. - void init_key (void); - - /// Called when thread exits to clean up the lock. - static void cleanup (void *ptr); - - /// Thread-specific key... - ACE_thread_key_t key_; - -private: - // FUZZ: disable check_for_ACE_Guard - typedef ACE_Guard Guard_Type; - // FUZZ: enable check_for_ACE_Guard - - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_TSS_Guard &)) - ACE_UNIMPLEMENTED_FUNC (ACE_TSS_Guard (const ACE_TSS_Guard &)) -}; - -/** - * @class ACE_TSS_Write_Guard - * - * @brief This class is similar to class ACE_TSS_Guard, though it - * acquires/releases a write-lock automatically (naturally, the - * ACE_LOCK it is instantiated with must support the appropriate - * API). - */ -template -class ACE_TSS_Write_Guard : public ACE_TSS_Guard -{ -public: - /// Implicitly and automatically acquire the thread-specific write lock. - ACE_TSS_Write_Guard (ACE_LOCK &lock, bool block = true); - - // = Lock accessors. - - /// Explicitly acquire the thread-specific write lock. - int acquire_write (void); - - /// Explicitly acquire the thread-specific write lock. - int acquire (void); - - /// Conditionally acquire the thread-specific write lock (i.e., won't block). - int tryacquire_write (void); - - /// Conditionally acquire the thread-specific write lock (i.e., won't block). - int tryacquire (void); - - // = Utility methods. - - /// Dump the state of an object. - void dump (void) const; - - // ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -private: - // FUZZ: disable check_for_ACE_Guard - typedef ACE_Guard Guard_Type; - typedef ACE_Write_Guard Write_Guard_Type; - // FUZZ: enable check_for_ACE_Guard -}; - -/** - * @class ACE_TSS_Read_Guard - * - * @brief This class is similar to class , though it - * acquires/releases a read lock automatically (naturally, the - * it is instantiated with must support the - * appropriate API). - */ -template -class ACE_TSS_Read_Guard : public ACE_TSS_Guard -{ -public: - /// Implicitly and automatically acquire the thread-specific read lock. - ACE_TSS_Read_Guard (ACE_LOCK &lock, bool block = true); - - // = Lock accessors. - /// Explicitly acquire the thread-specific read lock. - int acquire_read (void); - - /// Explicitly acquire the thread-specific read lock. - int acquire (void); - - /// Conditionally acquire the thread-specific read lock (i.e., won't - /// block). - int tryacquire_read (void); - - /// Conditionally acquire the thread-specific read lock (i.e., won't - /// block). - int tryacquire (void); - - // = Utility methods. - /// Dump the state of an object. - void dump (void) const; - - // ACE_ALLOC_HOOK_DECLARE; - // Declare the dynamic allocation hooks. -private: - // FUZZ: disable check_for_ACE_Guard - typedef ACE_Guard Guard_Type; - typedef ACE_Read_Guard Read_Guard_Type; - // FUZZ: enable check_for_ACE_Guard -}; - -#endif /* !(defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))) */ - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Guard_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Guard_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Guard_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_GUARD_T_H */ diff --git a/deps/acelite/ace/Guard_T.inl b/deps/acelite/ace/Guard_T.inl deleted file mode 100644 index 02d6989cd..000000000 --- a/deps/acelite/ace/Guard_T.inl +++ /dev/null @@ -1,169 +0,0 @@ -// -*- C++ -*- -// FUZZ: disable check_for_ACE_Guard - -#include "ace/RW_Thread_Mutex.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE int -ACE_Guard::acquire (void) -{ - return this->owner_ = this->lock_->acquire (); -} - -template ACE_INLINE int -ACE_Guard::tryacquire (void) -{ - return this->owner_ = this->lock_->tryacquire (); -} - -template ACE_INLINE int -ACE_Guard::release (void) -{ - if (this->owner_ == -1) - return -1; - else - { - this->owner_ = -1; - return this->lock_->release (); - } -} - -template ACE_INLINE -ACE_Guard::ACE_Guard (ACE_LOCK &l) - : lock_ (&l), - owner_ (0) -{ - this->acquire (); -} - -template ACE_INLINE -ACE_Guard::ACE_Guard (ACE_LOCK &l, bool block) - : lock_ (&l), - owner_ (0) -{ - if (block) - this->acquire (); - else - this->tryacquire (); -} - -template ACE_INLINE -ACE_Guard::ACE_Guard (ACE_LOCK &l, bool /* block */, int become_owner) - : lock_ (&l), - owner_ (become_owner == 0 ? -1 : 0) -{ -} - -// Implicitly and automatically acquire (or try to acquire) the -// lock. - -template ACE_INLINE -ACE_Guard::~ACE_Guard (void) -{ - this->release (); -} - -template ACE_INLINE bool -ACE_Guard::locked (void) const -{ - return this->owner_ != -1; -} - -template ACE_INLINE int -ACE_Guard::remove (void) -{ - return this->lock_->remove (); -} - -template ACE_INLINE void -ACE_Guard::disown (void) -{ - this->owner_ = -1; -} - -template ACE_INLINE -ACE_Write_Guard::ACE_Write_Guard (ACE_LOCK &m) - : ACE_Guard (&m) -{ - this->acquire_write (); -} - -template ACE_INLINE int -ACE_Write_Guard::acquire_write (void) -{ - return this->owner_ = this->lock_->acquire_write (); -} - -template ACE_INLINE int -ACE_Write_Guard::acquire (void) -{ - return this->owner_ = this->lock_->acquire_write (); -} - -template ACE_INLINE int -ACE_Write_Guard::tryacquire_write (void) -{ - return this->owner_ = this->lock_->tryacquire_write (); -} - -template ACE_INLINE int -ACE_Write_Guard::tryacquire (void) -{ - return this->owner_ = this->lock_->tryacquire_write (); -} - -template ACE_INLINE -ACE_Write_Guard::ACE_Write_Guard (ACE_LOCK &m, - bool block) - : ACE_Guard (&m) -{ - if (block) - this->acquire_write (); - else - this->tryacquire_write (); -} - -template ACE_INLINE int -ACE_Read_Guard::acquire_read (void) -{ - return this->owner_ = this->lock_->acquire_read (); -} - -template ACE_INLINE int -ACE_Read_Guard::acquire (void) -{ - return this->owner_ = this->lock_->acquire_read (); -} - -template ACE_INLINE int -ACE_Read_Guard::tryacquire_read (void) -{ - return this->owner_ = this->lock_->tryacquire_read (); -} - -template ACE_INLINE int -ACE_Read_Guard::tryacquire (void) -{ - return this->owner_ = this->lock_->tryacquire_read (); -} - -template ACE_INLINE -ACE_Read_Guard::ACE_Read_Guard (ACE_LOCK &m) - : ACE_Guard (&m) -{ - this->acquire_read (); -} - -template ACE_INLINE -ACE_Read_Guard::ACE_Read_Guard (ACE_LOCK &m, - bool block) - : ACE_Guard (&m) -{ - if (block) - this->acquire_read (); - else - this->tryacquire_read (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Handle_Gobbler.h b/deps/acelite/ace/Handle_Gobbler.h deleted file mode 100644 index 1ce1a2982..000000000 --- a/deps/acelite/ace/Handle_Gobbler.h +++ /dev/null @@ -1,65 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Handle_Gobbler.h - * - * @author Kirthika Parameswaran - * @author Irfan Pyarali - */ -//============================================================================= - - -#ifndef ACE_HANDLE_GOBBLER_H -#define ACE_HANDLE_GOBBLER_H -#include /**/ "ace/pre.h" - -#include "ace/Handle_Set.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Handle_Gobbler - * - * @brief This class gobbles up handles. - * - * This is useful when we need to control the number of handles - * available for a process. This class is mostly used for - * testing purposes. - */ -class ACE_Handle_Gobbler -{ -public: - /// Destructor. Cleans up any remaining handles. - inline ~ACE_Handle_Gobbler (void); - - /** - * Handles are opened continuously until the process runs out of - * them, and then @a n_handles_to_keep_available handles are closed - * (freed) thereby making them usable in the future. - */ - inline int consume_handles (size_t n_handles_to_keep_available); - - /// Free up @a n_handles. - inline int free_handles (size_t n_handles); - - /// All remaining handles are closed. - inline void close_remaining_handles (void); - -private: - typedef ACE_Handle_Set HANDLE_SET; - - /// The container which holds the open descriptors. - HANDLE_SET handle_set_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include "ace/Handle_Gobbler.inl" - -#include /**/ "ace/post.h" -#endif /* ACE_HANDLE_GOBBLER_H */ diff --git a/deps/acelite/ace/Handle_Gobbler.inl b/deps/acelite/ace/Handle_Gobbler.inl deleted file mode 100644 index 8bacb005d..000000000 --- a/deps/acelite/ace/Handle_Gobbler.inl +++ /dev/null @@ -1,76 +0,0 @@ -// -*- C++ -*- -// Since this is only included in Handle_Gobbler.h, these should be -// inline, not ACE_INLINE. -// FUZZ: disable check_for_inline - -#include "ace/ACE.h" -#include "ace/OS_NS_unistd.h" -#include "ace/OS_NS_fcntl.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -inline void -ACE_Handle_Gobbler::close_remaining_handles (void) -{ - ACE_Handle_Set_Iterator iter (this->handle_set_); - for (ACE_HANDLE h = iter (); h != ACE_INVALID_HANDLE; h = iter ()) - ACE_OS::close (h); -} - -inline -ACE_Handle_Gobbler::~ACE_Handle_Gobbler (void) -{ - this->close_remaining_handles (); -} - -inline int -ACE_Handle_Gobbler::free_handles (size_t n_handles) -{ - ACE_Handle_Set_Iterator iter (this->handle_set_); - for (ACE_HANDLE h = iter (); - h != ACE_INVALID_HANDLE && n_handles > 0; - --n_handles, h = iter ()) - ACE_OS::close (h); - - return 0; -} - -inline int -ACE_Handle_Gobbler::consume_handles (size_t n_handles_to_keep_available) -{ - int result = 0; - -#if defined(ACE_WIN32) - // On Win32, this style of gobbling doesn't seem to work. - ACE_UNUSED_ARG(n_handles_to_keep_available); - -#else - - while (1) - { - ACE_HANDLE handle = ACE_OS::open (ACE_DEV_NULL, O_WRONLY); - - if (handle == ACE_INVALID_HANDLE) - { - if (ACE::out_of_handles (errno)) - { - result = this->free_handles (n_handles_to_keep_available); - break; - } - else - { - result = -1; - break; - } - } - if (handle >= static_cast(FD_SETSIZE)) - break; - this->handle_set_.set_bit (handle); - } - -#endif /* ACE_WIN32 */ - - return result; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Handle_Ops.cpp b/deps/acelite/ace/Handle_Ops.cpp deleted file mode 100644 index 6d83f91b8..000000000 --- a/deps/acelite/ace/Handle_Ops.cpp +++ /dev/null @@ -1,42 +0,0 @@ -#include "ace/Handle_Ops.h" - -#include "ace/OS_NS_errno.h" -#include "ace/OS_NS_fcntl.h" -#include "ace/Time_Value.h" - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_HANDLE -ACE::handle_timed_open (ACE_Time_Value *timeout, - const ACE_TCHAR *name, - int flags, - int perms, - LPSECURITY_ATTRIBUTES sa) -{ - ACE_TRACE ("ACE::handle_timed_open"); - - if (timeout != 0) - { -#if !defined (ACE_WIN32) - // On Win32, ACE_NONBLOCK gets recognized as O_WRONLY so we - // don't use it there - flags |= ACE_NONBLOCK; -#endif /* ACE_WIN32 */ - - // Open the named pipe or file using non-blocking mode... - ACE_HANDLE const handle = ACE_OS::open (name, flags, perms, sa); - - if (handle == ACE_INVALID_HANDLE - && (errno == EWOULDBLOCK - && (timeout->sec () > 0 || timeout->usec () > 0))) - // This expression checks if we were polling. - errno = ETIMEDOUT; - - return handle; - } - else - return ACE_OS::open (name, flags, perms, sa); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Handle_Ops.h b/deps/acelite/ace/Handle_Ops.h deleted file mode 100644 index bc95fd30c..000000000 --- a/deps/acelite/ace/Handle_Ops.h +++ /dev/null @@ -1,48 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Handle_Ops.h - * - * Handle operations. - */ -//============================================================================= - -#ifndef ACE_HANDLE_OPS_H -#define ACE_HANDLE_OPS_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Global_Macros.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Time_Value; - -// = Operations on HANDLEs. -namespace ACE -{ - /** - * Wait up to @a timeout amount of time to actively open a device. - * This method doesn't perform the @c connect, it just does the - * timed wait. - */ - extern ACE_Export ACE_HANDLE handle_timed_open ( - ACE_Time_Value *timeout, - const ACE_TCHAR *name, - int flags, - int perms, - LPSECURITY_ATTRIBUTES sa = 0); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#endif /* ACE_HANDLE_OPS_H */ diff --git a/deps/acelite/ace/Handle_Set.cpp b/deps/acelite/ace/Handle_Set.cpp deleted file mode 100644 index 8f1831757..000000000 --- a/deps/acelite/ace/Handle_Set.cpp +++ /dev/null @@ -1,523 +0,0 @@ -// Handle_Set.cpp -#include "ace/Handle_Set.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/Handle_Set.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Handle_Set) - - // ACE_MSB_MASK is only used here. - // This needs to go here to avoid overflow problems on some compilers. -#if defined (ACE_HANDLE_SET_USES_FD_ARRAY) - // Do we have an fd_mask? -# define ACE_MSB_MASK (~(1 << (NFDBITS - 1))) -#else /* ! ACE_HANDLE_SET_USES_FD_ARRAY */ -# define ACE_MSB_MASK (~((fd_mask) 1 << (NFDBITS - 1))) -#endif /* ! ACE_HANDLE_SET_USES_FD_ARRAY */ - -#if defined (ACE_LINUX) && __GLIBC__ > 1 && __GLIBC_MINOR__ >= 1 && !defined (_XOPEN_SOURCE) - // XPG4.2 requires the fds_bits member name, so it is not enabled by - // default on Linux/glibc-2.1.x systems. Instead use "__fds_bits." - // Ugly, but "what are you going to do?" 8-) -#define fds_bits __fds_bits -#elif defined ACE_FDS_BITS -#define fds_bits ACE_FDS_BITS -#endif /* ACE_LINUX && __GLIBC__ > 1 && __GLIBC_MINOR__ >= 1 && !_XOPEN_SOURCE */ - -void -ACE_Handle_Set::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Handle_Set::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nsize_ = %d"), this->size_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nmax_handle_ = %d"), this->max_handle_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n[ "))); - -#if defined (ACE_HANDLE_SET_USES_FD_ARRAY) - for (size_t i = 0; i < (size_t) this->mask_.fd_count + 1; i++) - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT (" %x "), this->mask_.fd_array[i])); -#else /* !ACE_HANDLE_SET_USES_FD_ARRAY */ - for (ACE_HANDLE i = 0; i < this->max_handle_ + 1; i++) - if (this->is_set (i)) - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT (" %d "), i)); -#endif /* ACE_HANDLE_SET_USES_FD_ARRAY */ - - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT (" ]\n"))); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -// Table that maps bytes to counts of the enabled bits in each value -// from 0 to 255, -// -// nbits_[0] == 0 -// -// because there are no bits enabled for the value 0. -// -// nbits_[5] == 2 -// -// because there are 2 bits enabled in the value 5, i.e., it's -// 101 in binary. - -const char ACE_Handle_Set::nbits_[256] = -{ - 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, - 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, - 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, - 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, - 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8}; - -// Constructor, initializes the bitmask to all 0s. - -ACE_Handle_Set::ACE_Handle_Set (void) -{ - ACE_TRACE ("ACE_Handle_Set::ACE_Handle_Set"); - this->reset (); -} - -ACE_Handle_Set::ACE_Handle_Set (const fd_set &fd_mask) -{ - ACE_TRACE ("ACE_Handle_Set::ACE_Handle_Set"); - this->reset (); - ACE_OS::memcpy ((void *) &this->mask_, - (void *) &fd_mask, - sizeof this->mask_); -#if !defined (ACE_HANDLE_SET_USES_FD_ARRAY) - this->sync (ACE_Handle_Set::MAXSIZE); -#if defined (ACE_HAS_BIG_FD_SET) - this->min_handle_ = 0; -#endif /* ACE_HAS_BIG_FD_SET */ -#endif /* !ACE_HANDLE_SET_USES_FD_ARRAY */ -} - -// Counts the number of bits enabled in N. Uses a table lookup to -// speed up the count. - -int -ACE_Handle_Set::count_bits (u_long n) -{ - - ACE_TRACE ("ACE_Handle_Set::count_bits"); -#if defined (ACE_HAS_HANDLE_SET_OPTIMIZED_FOR_SELECT) - int rval = 0; - - // Count the number of enabled bits in . This algorithm is very - // fast, i.e., O(enabled bits in n). - - for (u_long m = n; - m != 0; - m &= m - 1) - rval++; - - return rval; -#else - return (ACE_Handle_Set::nbits_[n & 0xff] - + ACE_Handle_Set::nbits_[(n >> 8) & 0xff] - + ACE_Handle_Set::nbits_[(n >> 16) & 0xff] - + ACE_Handle_Set::nbits_[(n >> 24) & 0xff]); -#endif /* ACE_HAS_HANDLE_SET_OPTIMIZED_FOR_SELECT */ -} - -#if defined (ACE_HAS_BIG_FD_SET) -// Find the bit position counting from right to left worst case -// (1<<31) is 8. - -int -ACE_Handle_Set::bitpos (u_long bit) -{ - int l = 0; - u_long n = bit - 1; - - // This is a fast count method when have the most significative bit. - - while (n >> 8) - { - n >>= 8; - l += 8; - } - - // Is greater than 15? - if (n & 16) - { - n >>= 4; - l += 4; - } - - // Count number remaining bits. - while (n != 0) - { - n &= n - 1; - l++; - } - return l; -} -#endif /* ACE_HAS_BIG_FD_SET */ - -// Synchronize the underlying FD_SET with the MAX_FD and the SIZE. - -#if defined (ACE_USE_SHIFT_FOR_EFFICIENCY) -// These don't work because shifting right 3 bits is not the same as -// dividing by 3, e.g., dividing by 8 requires shifting right 3 bits. -// In order to do the shift, we need to calculate the number of bits -// at some point. -#define ACE_DIV_BY_WORDSIZE(x) ((x) >> ((int) ACE_Handle_Set::WORDSIZE)) -#define ACE_MULT_BY_WORDSIZE(x) ((x) << ((int) ACE_Handle_Set::WORDSIZE)) -#else -#define ACE_DIV_BY_WORDSIZE(x) ((x) / ((int) ACE_Handle_Set::WORDSIZE)) -#define ACE_MULT_BY_WORDSIZE(x) ((x) * ((int) ACE_Handle_Set::WORDSIZE)) -#endif /* ACE_USE_SHIFT_FOR_EFFICIENCY */ - -void -ACE_Handle_Set::sync (ACE_HANDLE max) -{ - ACE_TRACE ("ACE_Handle_Set::sync"); -#if !defined (ACE_HANDLE_SET_USES_FD_ARRAY) - fd_mask *maskp = (fd_mask *)(this->mask_.fds_bits); - this->size_ = 0; - - for (int i = ACE_DIV_BY_WORDSIZE (max - 1); - i >= 0; - i--) - this->size_ += ACE_Handle_Set::count_bits (maskp[i]); - - this->set_max (max); -#else - ACE_UNUSED_ARG (max); -#endif /* !ACE_HANDLE_SET_USES_FD_ARRAY */ -} - -// Resets the MAX_FD after a clear of the original MAX_FD. - -void -ACE_Handle_Set::set_max (ACE_HANDLE current_max) -{ - ACE_TRACE ("ACE_Handle_Set::set_max"); -#if !defined(ACE_HANDLE_SET_USES_FD_ARRAY) - fd_mask * maskp = (fd_mask *)(this->mask_.fds_bits); - - if (this->size_ == 0) - this->max_handle_ = ACE_INVALID_HANDLE; - else - { - int i; - - for (i = ACE_DIV_BY_WORDSIZE (current_max - 1); - maskp[i] == 0; - i--) - continue; - this->max_handle_ = ACE_MULT_BY_WORDSIZE (i); - for (fd_mask val = maskp[i]; - (val & ~1) != 0; // This obscure code is needed since "bit 0" is in location 1... - val = (val >> 1) & ACE_MSB_MASK) - ++this->max_handle_; - } - - // Do some sanity checking... - if (this->max_handle_ >= ACE_Handle_Set::MAXSIZE) - this->max_handle_ = ACE_Handle_Set::MAXSIZE - 1; -#else - ACE_UNUSED_ARG (current_max); -#endif /* !ACE_HANDLE_SET_USES_FD_ARRAY */ -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Handle_Set_Iterator) - -void -ACE_Handle_Set_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Handle_Set_Iterator::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); -#if defined(ACE_HANDLE_SET_USES_FD_ARRAY) || !defined(ACE_HAS_BIG_FD_SET) - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nhandle_index_ = %d"), this->handle_index_)); -#elif defined(ACE_HAS_BIG_FD_SET) - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nword_max_ = %d"), this->word_max_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nword_val_ = %d"), this->word_val_)); -#endif - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nword_num_ = %d"), this->word_num_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_HANDLE -ACE_Handle_Set_Iterator::operator () (void) -{ - ACE_TRACE ("ACE_Handle_Set_Iterator::operator"); -#if defined (ACE_HANDLE_SET_USES_FD_ARRAY) - if (this->handle_index_ < this->handles_.mask_.fd_count) - // Return the handle and advance the iterator. - return (ACE_HANDLE) this->handles_.mask_.fd_array[this->handle_index_++]; - else - return ACE_INVALID_HANDLE; - -#elif !defined (ACE_HAS_BIG_FD_SET) /* !ACE_HANDLE_SET_USES_FD_ARRAY */ - // No sense searching further than the max_handle_ + 1; - ACE_HANDLE maxhandlep1 = this->handles_.max_handle_ + 1; - - // HP-UX 11 plays some games with the fd_mask type - fd_mask is - // defined as an int_32t, but the fds_bits is an array of longs. - // This makes plainly indexing through the array by hand tricky, - // since the FD_* macros treat the array as int32_t. So the bits - // are in the right place for int32_t, even though the array is - // long. This, they say, is to preserve the same in-memory layout - // for 32-bit and 64-bit processes. So, we play the same game as - // the FD_* macros to get the bits right. On all other systems, - // this amounts to practically a NOP, since this is what would have - // been done anyway, without all this type jazz. - fd_mask * maskp = (fd_mask *)(this->handles_.mask_.fds_bits); - - if (this->handle_index_ >= maxhandlep1) - // We've seen all the handles we're interested in seeing for this - // iterator. - return ACE_INVALID_HANDLE; - else - { - ACE_HANDLE result = this->handle_index_; - - // Increment the iterator and advance to the next bit in this - // word. - this->handle_index_++; - this->word_val_ = (this->word_val_ >> 1) & ACE_MSB_MASK; - - // If we've examined all the bits in this word, we'll go onto - // the next word. - - if (this->word_val_ == 0) - { - // Start the handle_index_ at the beginning of the next word - // and then loop until we've found the first non-zero bit or - // we run past the of the bitset. - - for (this->handle_index_ = ACE_MULT_BY_WORDSIZE(++this->word_num_); - this->handle_index_ < maxhandlep1 - && maskp[this->word_num_] == 0; - this->word_num_++) - this->handle_index_ += ACE_Handle_Set::WORDSIZE; - - // If the bit index becomes >= the maxhandlep1 that means - // there weren't any more bits set that we want to consider. - // Therefore, we'll just store the maxhandlep1, which will - // cause to return - // immediately next time it's called. - if (this->handle_index_ >= maxhandlep1) - { - this->handle_index_ = maxhandlep1; - return result; - } - else - // Load the bits of the next word. - this->word_val_ = maskp[this->word_num_]; - } - - // Loop until we get to have its least significant - // bit enabled, keeping track of which this - // represents (this information is used by subsequent calls to - // ). - for (; - ACE_BIT_DISABLED (this->word_val_, 1); - this->handle_index_++) - this->word_val_ = (this->word_val_ >> 1) & ACE_MSB_MASK; - - return result; - } -#else /* !ACE_HAS_BIG_FD_SET */ - // Find the first word in fds_bits with bit on - u_long lsb = this->word_val_; - - if (lsb == 0) - { - do - { - // We have exceeded the word count in Handle_Set? - if (++this->word_num_ >= this->word_max_) - return ACE_INVALID_HANDLE; - - lsb = this->handles_.mask_.fds_bits[this->word_num_]; - } - while (lsb == 0); - - // Set index to word boundary. - this->handle_index_ = ACE_MULT_BY_WORDSIZE (this->word_num_); - - // Put new word_val. - this->word_val_ = lsb; - - // Find the least significative bit. - lsb &= ~(lsb - 1); - - // Remove least significative bit. - this->word_val_ ^= lsb; - - // Save to calculate bit distance. - this->oldlsb_ = lsb; - - // Move index to least significative bit. - while (lsb >>= 1) - this->handle_index_++; - } - else - { - // Find the least significative bit. - lsb &= ~(lsb - 1); - - // Remove least significative bit. - this->word_val_ ^= lsb; - - u_long n = lsb - this->oldlsb_; - - // Move index to bit distance between new lsb and old lsb. - do - { - this->handle_index_++; - n &= n >> 1; - } - while (n != 0); - - this->oldlsb_ = lsb; - } - - return this->handle_index_; -#endif /* ACE_HANDLE_SET_USES_FD_ARRAY */ -} - -ACE_Handle_Set_Iterator::ACE_Handle_Set_Iterator (const ACE_Handle_Set &hs) - : handles_ (hs), -#if !defined (ACE_HAS_BIG_FD_SET) || defined (ACE_HANDLE_SET_USES_FD_ARRAY) - handle_index_ (0), - word_num_ (-1) -#elif defined (ACE_HAS_BIG_FD_SET) - handle_index_ (0), - oldlsb_ (0), - word_max_ (hs.max_handle_ == ACE_INVALID_HANDLE - ? 0 - : ((ACE_DIV_BY_WORDSIZE (hs.max_handle_)) + 1)) -#endif /* ACE_HAS_BIG_FD_SET */ -{ - ACE_TRACE ("ACE_Handle_Set_Iterator::ACE_Handle_Set_Iterator"); -#if !defined (ACE_HANDLE_SET_USES_FD_ARRAY) && !defined (ACE_HAS_BIG_FD_SET) - // No sense searching further than the max_handle_ + 1; - ACE_HANDLE maxhandlep1 = - this->handles_.max_handle_ + 1; - - fd_mask *maskp = - (fd_mask *)(this->handles_.mask_.fds_bits); - - // Loop until we've found the first non-zero bit or we run past the - // of the bitset. - while (this->handle_index_ < maxhandlep1 - && maskp[++this->word_num_] == 0) - this->handle_index_ += ACE_Handle_Set::WORDSIZE; - - // If the bit index becomes >= the maxhandlep1 that means there - // weren't any bits set. Therefore, we'll just store the - // maxhandlep1, which will cause to return - // immediately. - if (this->handle_index_ >= maxhandlep1) - this->handle_index_ = maxhandlep1; - else - // Loop until we get to have its least significant bit - // enabled, keeping track of which this represents - // (this information is used by ). - for (this->word_val_ = maskp[this->word_num_]; - ACE_BIT_DISABLED (this->word_val_, 1) - && this->handle_index_ < maxhandlep1; - this->handle_index_++) - this->word_val_ = (this->word_val_ >> 1) & ACE_MSB_MASK; -#elif !defined (ACE_HANDLE_SET_USES_FD_ARRAY) && defined (ACE_HAS_BIG_FD_SET) - if (this->word_max_==0) - { - this->word_num_ = -1; - this->word_val_ = 0; - } - else - { - this->word_num_ = - ACE_DIV_BY_WORDSIZE (this->handles_.min_handle_) - 1; - this->word_val_ = 0; - } -#endif /* !ACE_HANDLE_SET_USES_FD_ARRAY && !ACE_HAS_BIG_FD_SET */ -} - -void -ACE_Handle_Set_Iterator::reset_state (void) -{ - ACE_TRACE ("ACE_Handle_Set_Iterator::reset_state"); - -#if !defined (ACE_HAS_BIG_FD_SET) || defined (ACE_HANDLE_SET_USES_FD_ARRAY) - this->handle_index_ = 0; - this->word_num_ = -1; -#elif defined (ACE_HAS_BIG_FD_SET) - this->oldlsb_ = 0; - this->word_max_ = - this->handles_.max_handle_ == ACE_INVALID_HANDLE ? 0 - : ((ACE_DIV_BY_WORDSIZE (this->handles_.max_handle_)) + 1); -#endif /* ACE_HAS_BIG_FD_SET */ - -#if !defined (ACE_HANDLE_SET_USES_FD_ARRAY) && !defined (ACE_HAS_BIG_FD_SET) - // No sense searching further than the max_handle_ + 1; - ACE_HANDLE maxhandlep1 = - this->handles_.max_handle_ + 1; - - fd_mask *maskp = - (fd_mask *)(this->handles_.mask_.fds_bits); - - // Loop until we've found the first non-zero bit or we run past the - // of the bitset. - while (this->handle_index_ < maxhandlep1 - && maskp[++this->word_num_] == 0) - this->handle_index_ += ACE_Handle_Set::WORDSIZE; - - // If the bit index becomes >= the maxhandlep1 that means there - // weren't any bits set. Therefore, we'll just store the - // maxhandlep1, which will cause to return - // immediately. - if (this->handle_index_ >= maxhandlep1) - this->handle_index_ = maxhandlep1; - else - // Loop until we get to have its least significant bit - // enabled, keeping track of which this represents - // (this information is used by ). - for (this->word_val_ = maskp[this->word_num_]; - ACE_BIT_DISABLED (this->word_val_, 1) - && this->handle_index_ < maxhandlep1; - this->handle_index_++) - this->word_val_ = (this->word_val_ >> 1) & ACE_MSB_MASK; -#elif !defined (ACE_HANDLE_SET_USES_FD_ARRAY) && defined (ACE_HAS_BIG_FD_SET) - if (this->word_max_==0) - { - this->word_num_ = -1; - this->word_val_ = 0; - } - else - { - this->word_num_ = - ACE_DIV_BY_WORDSIZE (this->handles_.min_handle_) - 1; - this->word_val_ = 0; - } -#endif /* !ACE_HANDLE_SET_USES_FD_ARRAY && !ACE_HAS_BIG_FD_SET */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Handle_Set.h b/deps/acelite/ace/Handle_Set.h deleted file mode 100644 index 4e4cf36ab..000000000 --- a/deps/acelite/ace/Handle_Set.h +++ /dev/null @@ -1,239 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Handle_Set.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_HANDLE_SET_H -#define ACE_HANDLE_SET_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/os_include/sys/os_select.h" -#include "ace/os_include/os_limits.h" - -// Default size of the ACE Reactor. -#if defined (FD_SETSIZE) - int const ACE_FD_SETSIZE = FD_SETSIZE; -#else /* !FD_SETSIZE */ -# define ACE_FD_SETSIZE FD_SETSIZE -#endif /* ACE_FD_SETSIZE */ - -#if defined(FD_SETSIZE) && defined(__FD_SETSIZE) && (FD_SETSIZE > __FD_SETSIZE) -#error FD_SETSIZE definition is too large, please correct! -#endif - -#if !defined (ACE_DEFAULT_SELECT_REACTOR_SIZE) -# define ACE_DEFAULT_SELECT_REACTOR_SIZE ACE_FD_SETSIZE -#endif /* ACE_DEFAULT_SELECT_REACTOR_SIZE */ - -#if defined (ACE_WIN32) || defined (ACE_MQX) -# define ACE_HANDLE_SET_USES_FD_ARRAY -#endif - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Handle_Set - * - * @brief C++ wrapper facade for the socket @c fd_set abstraction. - * - * This abstraction is a very efficient wrapper facade over - * @c fd_set. In particular, no range checking is performed, so - * it's important not to set or clear bits that are outside the - * @c ACE_DEFAULT_SELECT_REACTOR_SIZE. - */ -class ACE_Export ACE_Handle_Set -{ -public: - friend class ACE_Handle_Set_Iterator; - - enum - { - MAXSIZE = ACE_DEFAULT_SELECT_REACTOR_SIZE - }; - - /// Constructor, initializes the bitmask to all 0s. - ACE_Handle_Set (void); - - /** - * Constructor, initializes the handle set from a given mask. - */ - ACE_Handle_Set (const fd_set &mask); - - // = Methods for manipulating bitsets. - /// Initialize the bitmask to all 0s and reset the associated fields. - void reset (void); - - /** - * Checks whether @a handle is enabled. No range checking is - * performed so @a handle must be less than - * @c ACE_DEFAULT_SELECT_REACTOR_SIZE. - */ - int is_set (ACE_HANDLE handle) const; - - /// Enables the @a handle. No range checking is performed so @a handle - /// must be less than @c ACE_DEFAULT_SELECT_REACTOR_SIZE. - void set_bit (ACE_HANDLE handle); - - /// Disables the @a handle. No range checking is performed so - /// @a handle must be less than @c ACE_DEFAULT_SELECT_REACTOR_SIZE. - void clr_bit (ACE_HANDLE handle); - - /// Returns a count of the number of enabled bits. - int num_set (void) const; - - /// Returns the number of the large bit. - ACE_HANDLE max_set (void) const; - - /** - * Rescan the underlying @c fd_set up to handle @a max to find the new - * (highest bit set) and (how many bits set) values. - * This is useful for evaluating the changes after the handle set has - * been manipulated in some way other than member functions; for example, - * after - ACE_Select_Reactor_Handle_Set dispatch_set_; - - /// Tracks handles that are waited for by . - ACE_Select_Reactor_Handle_Set ready_set_; - - /// Defined as a pointer to allow overriding by derived classes... - ACE_Timer_Queue *timer_queue_; - - /// Handle signals without requiring global/static variables. - ACE_Sig_Handler *signal_handler_; - - /// Callback object that unblocks the ACE_Select_Reactor if it's - /// sleeping. - ACE_Reactor_Notify *notify_handler_; - - /// Keeps track of whether we should delete the timer queue (if we - /// didn't create it, then we don't delete it). - bool delete_timer_queue_; - - /// Keeps track of whether we should delete the signal handler (if we - /// didn't create it, then we don't delete it). - bool delete_signal_handler_; - - /// Keeps track of whether we need to delete the notify handler (if - /// we didn't create it, then we don't delete it). - bool delete_notify_handler_; - - /// True if we've been initialized yet... - bool initialized_; - - /// Restart the event-loop method automatically when - /// . - - if (number_of_active_handles == 0) - { - do - { - if (this->timer_queue_ == 0) - return 0; - - this_timeout = - this->timer_queue_->calculate_timeout (max_wait_time, - &timer_buf); -#ifdef ACE_WIN32 - // This arg is ignored on Windows and causes pointer - // truncation warnings on 64-bit compiles. - int const width = 0; -#else - int const width = this->handler_rep_.max_handlep1 (); -#endif /* ACE_WIN32 */ - - dispatch_set.rd_mask_ = this->wait_set_.rd_mask_; - dispatch_set.wr_mask_ = this->wait_set_.wr_mask_; - dispatch_set.ex_mask_ = this->wait_set_.ex_mask_; - number_of_active_handles = ACE_OS::select (width, - dispatch_set.rd_mask_, - dispatch_set.wr_mask_, - dispatch_set.ex_mask_, - this_timeout); - } - while (number_of_active_handles == -1 && this->handle_error () > 0); - - if (number_of_active_handles > 0) - { -#if !defined (ACE_WIN32) - // Resynchronize the fd_sets so their "max" is set properly. - dispatch_set.rd_mask_.sync (this->handler_rep_.max_handlep1 ()); - dispatch_set.wr_mask_.sync (this->handler_rep_.max_handlep1 ()); - dispatch_set.ex_mask_.sync (this->handler_rep_.max_handlep1 ()); -#endif /* ACE_WIN32 */ - } - else if (number_of_active_handles == -1) - { - // Normally, select() will reset the bits in dispatch_set - // so that only those filed descriptors that are ready will - // have bits set. However, when an error occurs, the bit - // set remains as it was when the select call was first made. - // Thus, we now have a dispatch_set that has every file - // descriptor that was originally waited for, which is not - // correct. We must clear all the bit sets because we - // have no idea if any of the file descriptors is ready. - // - // NOTE: We dont have a test case to reproduce this - // problem. But pleae dont ignore this and remove it off. - dispatch_set.rd_mask_.reset (); - dispatch_set.wr_mask_.reset (); - dispatch_set.ex_mask_.reset (); - } - } - - // Return the number of events to dispatch. - return number_of_active_handles; -} - -template int -ACE_Select_Reactor_T::dispatch_timer_handlers - (int &number_of_handlers_dispatched) -{ - number_of_handlers_dispatched += this->timer_queue_->expire (); - - return 0; -} - -template int -ACE_Select_Reactor_T::dispatch_notification_handlers - (ACE_Select_Reactor_Handle_Set &dispatch_set, - int &number_of_active_handles, - int &number_of_handlers_dispatched) -{ - // Check to see if the ACE_HANDLE associated with the - // Select_Reactor's notify hook is enabled. If so, it means that - // one or more other threads are trying to update the - // ACE_Select_Reactor_T's internal tables or the notify pipe is - // enabled. We'll handle all these threads and notifications, and - // then break out to continue the event loop. - int const n = - this->notify_handler_->dispatch_notifications (number_of_active_handles, - dispatch_set.rd_mask_); - - if (n == -1) - return -1; - else - { - number_of_handlers_dispatched += n; - number_of_active_handles -= n; - } - - // Same as dispatch_timer_handlers - // No need to do anything with the state changed. That is because - // unbind already handles the case where someone unregister some - // kind of handle and unbind it. (::unbind calls the function - // state_changed () to reflect ant change with that) - // return this->state_changed_ ? -1 : 0; - return 0; -} - -template int -ACE_Select_Reactor_T::dispatch_io_set - (int number_of_active_handles, - int &number_of_handlers_dispatched, - int mask, - ACE_Handle_Set &dispatch_mask, - ACE_Handle_Set &ready_mask, - ACE_EH_PTMF callback) -{ - ACE_TRACE ("ACE_Select_Reactor_T::dispatch_io_set"); - ACE_HANDLE handle; - - ACE_Handle_Set_Iterator handle_iter (dispatch_mask); - - while ((handle = handle_iter ()) != ACE_INVALID_HANDLE && - number_of_handlers_dispatched < number_of_active_handles) - { - ++number_of_handlers_dispatched; - - this->notify_handle (handle, - mask, - ready_mask, - this->handler_rep_.find (handle), - callback); - - // clear the bit from that dispatch mask, - // so when we need to restart the iteration (rebuilding the iterator...) - // we will not dispatch the already dispatched handlers - this->clear_dispatch_mask (handle, mask); - - if (this->state_changed_) - { - - handle_iter.reset_state (); - this->state_changed_ = false; - } - } - - return 0; -} - -template int -ACE_Select_Reactor_T::dispatch_io_handlers - (ACE_Select_Reactor_Handle_Set &dispatch_set, - int &number_of_active_handles, - int &number_of_handlers_dispatched) -{ - ACE_TRACE ("ACE_Select_Reactor_T::dispatch_io_handlers"); - - // Handle output events (this code needs to come first to handle the - // obscure case of piggy-backed data coming along with the final - // handshake message of a nonblocking connection). - - if (this->dispatch_io_set (number_of_active_handles, - number_of_handlers_dispatched, - ACE_Event_Handler::WRITE_MASK, - dispatch_set.wr_mask_, - this->ready_set_.wr_mask_, - &ACE_Event_Handler::handle_output) == -1) - { - number_of_active_handles -= number_of_handlers_dispatched; - return -1; - } - - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Select_Reactor_T::dispatch - EXCEPT\n"))); - if (this->dispatch_io_set (number_of_active_handles, - number_of_handlers_dispatched, - ACE_Event_Handler::EXCEPT_MASK, - dispatch_set.ex_mask_, - this->ready_set_.ex_mask_, - &ACE_Event_Handler::handle_exception) == -1) - { - number_of_active_handles -= number_of_handlers_dispatched; - return -1; - } - - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("ACE_Select_Reactor_T::dispatch - READ\n"))); - if (this->dispatch_io_set (number_of_active_handles, - number_of_handlers_dispatched, - ACE_Event_Handler::READ_MASK, - dispatch_set.rd_mask_, - this->ready_set_.rd_mask_, - &ACE_Event_Handler::handle_input) == -1) - { - number_of_active_handles -= number_of_handlers_dispatched; - return -1; - } - - number_of_active_handles -= number_of_handlers_dispatched; - return 0; -} - -template int -ACE_Select_Reactor_T::dispatch - (int active_handle_count, - ACE_Select_Reactor_Handle_Set &dispatch_set) -{ - ACE_TRACE ("ACE_Select_Reactor_T::dispatch"); - - int io_handlers_dispatched = 0; - int other_handlers_dispatched = 0; - int signal_occurred = 0; - // The following do/while loop keeps dispatching as long as there - // are still active handles. Note that the only way we should ever - // iterate more than once through this loop is if signals occur - // while we're dispatching other handlers. - - do - { - // We expect that the loop will decrease the number of active - // handles in each iteration. If it does not, then something is - // inconsistent in the state of the Reactor and we should avoid - // the loop. Please read the comments on bug 2540 for more - // details. - int initial_handle_count = active_handle_count; - - // Note that we keep track of changes to our state. If any of - // the dispatch_*() methods below return -1 it means that the - // state has changed as the result of an - // being dispatched. This means that we - // need to bail out and rerun the select() loop since our - // existing notion of handles in may no longer be - // correct. - // - // In the beginning, our state starts out unchanged. After - // every iteration (i.e., due to signals), our state starts out - // unchanged again. - - this->state_changed_ = false; - - // Perform the Template Method for dispatching all the handlers. - - // First check for interrupts. - if (active_handle_count == -1) - { - // Bail out -- we got here since /. Pass over both the Event_Handler *and* the - * @a mask to allow the caller to dictate which - * method the will invoke. The ACE_Time_Value - * indicates how long to blocking trying to notify the - * . If @a timeout == 0, the caller will block until - * action is possible, else will wait until the relative time - * specified in *@a timeout elapses). - */ - virtual int notify (ACE_Event_Handler * = 0, - ACE_Reactor_Mask = ACE_Event_Handler::EXCEPT_MASK, - ACE_Time_Value * = 0); - - /** - * Set the maximum number of times that the - * ACE_Select_Reactor_Notify::handle_input() method will iterate and - * dispatch the ACE_Event_Handlers that are passed in via the - * notify pipe before breaking out of its recv loop. By default, - * this is set to -1, which means "iterate until the pipe is empty." - * Setting this to a value like "1 or 2" will increase "fairness" - * (and thus prevent starvation) at the expense of slightly higher - * dispatching overhead. - */ - virtual void max_notify_iterations (int); - - /** - * Get the maximum number of times that the - * ACE_Select_Reactor_Notify::handle_input() method will iterate and - * dispatch the ACE_Event_Handlers that are passed in via the - * notify pipe before breaking out of its recv loop. - */ - virtual int max_notify_iterations (void); - - /// Get the existing restart value. - virtual bool restart (void); - - /// Set a new value for restart and return the original value. - virtual bool restart (bool r); - - /// Set position that the main ACE_Select_Reactor thread is requeued in the - /// list of waiters during a callback. - virtual void requeue_position (int); - - /// Get position that the main ACE_Select_Reactor thread is requeued in the - /// list of waiters during a callback. - virtual int requeue_position (void); - - // = Low-level wait_set mask manipulation methods. - /// GET/SET/ADD/CLR the dispatch mask "bit" bound with the @a eh and - /// @a mask. - virtual int mask_ops (ACE_Event_Handler *eh, - ACE_Reactor_Mask mask, - int ops); - - /// GET/SET/ADD/CLR the dispatch MASK "bit" bound with the @a handle - /// and @a mask. - virtual int mask_ops (ACE_HANDLE handle, - ACE_Reactor_Mask mask, - int ops); - - // = Low-level ready_set mask manipulation methods. - /// GET/SET/ADD/CLR the ready "bit" bound with the @a eh and @a mask. - virtual int ready_ops (ACE_Event_Handler *eh, - ACE_Reactor_Mask mask, - int ops); - - /// GET/SET/ADD/CLR the ready "bit" bound with the @a handle and @a mask. - virtual int ready_ops (ACE_HANDLE handle, - ACE_Reactor_Mask, - int ops); - - /// Wake up all threads in waiting in the event loop - virtual void wakeup_all_threads (void); - - // = Only the owner thread can perform a . - - /// Set the new owner of the thread and return the old owner. - virtual int owner (ACE_thread_t n_id, ACE_thread_t *o_id = 0); - - /// Return the current owner of the thread. - virtual int owner (ACE_thread_t *); - - // = Miscellaneous Handler operations. - - /** - * Return the Event_Handler associated with @a handle. Return 0 if - * @a handle is not registered. - */ - virtual ACE_Event_Handler *find_handler (ACE_HANDLE handle); - - /** - * Check to see if @a handle is associated with a valid Event_Handler - * bound to @a mask. Return the @a eh associated with this @a handler - * if @a eh != 0. - */ - virtual int handler (ACE_HANDLE handle, - ACE_Reactor_Mask mask, - ACE_Event_Handler **eh = 0); - - /** - * Check to see if @a signum is associated with a valid Event_Handler - * bound to a signal. Return the @a eh associated with this - * handler if @a eh != 0. - */ - virtual int handler (int signum, - ACE_Event_Handler ** = 0); - - /// Returns true if we've been successfully initialized, else false. - virtual bool initialized (void); - - /// Returns the current size of the Reactor's internal descriptor - /// table. - virtual size_t size (void) const; - - /** - * Returns a reference to the ACE_Reactor_Token that is - * used to serialize the internal processing logic. - * This can be useful for situations where you need to avoid - * deadlock efficiently when ACE_Event_Handlers are used in - * multiple threads. - */ - virtual ACE_Lock &lock (void); - - /// Dump the state of an object. - virtual void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - // = Internal methods that do the actual work. - - // All of these methods assume that the token - // lock is held by the public methods that call down to them. - - /// Do the work of actually binding the @a handle and @a eh with the - /// @a mask. - virtual int register_handler_i (ACE_HANDLE handle, - ACE_Event_Handler *eh, - ACE_Reactor_Mask mask); - - /// Register a set of @a handles. - virtual int register_handler_i (const ACE_Handle_Set &handles, - ACE_Event_Handler *handler, - ACE_Reactor_Mask mask); - - /// Do the work of actually unbinding the @a handle and @a eh with the - /// @a mask. - virtual int remove_handler_i (ACE_HANDLE handle, - ACE_Reactor_Mask); - - /// Remove a set of @a handles. - virtual int remove_handler_i (const ACE_Handle_Set &handles, - ACE_Reactor_Mask); - - /// Suspend the associated with @a handle - virtual int suspend_i (ACE_HANDLE handle); - - /// Check to see if the associated with @a handle is - /// suspended. Returns 0 if not, 1 if so. - virtual int is_suspended_i (ACE_HANDLE handle); - - /// Resume the associated with @a handle - virtual int resume_i (ACE_HANDLE handle); - - /// Implement the public handler method. - virtual ACE_Event_Handler *find_handler_i (ACE_HANDLE handle); - - /// Implement the public handler method. - virtual int handler_i (ACE_HANDLE handle, - ACE_Reactor_Mask, - ACE_Event_Handler ** = 0); - - /// Implement the public handler method. - virtual int handler_i (int signum, ACE_Event_Handler ** = 0); - - /** - * Check if there are any HANDLEs enabled in the , and - * if so, update the @a handle_set and return the number ready. If - * there aren't any HANDLEs enabled return 0. - */ - virtual int any_ready (ACE_Select_Reactor_Handle_Set &handle_set); - - /// Implement the method, assuming that the Sig_Guard is - /// being held - virtual int any_ready_i (ACE_Select_Reactor_Handle_Set &handle_set); - - /// Take corrective action when errors occur. - virtual int handle_error (void); - - /// Make sure the handles are all valid. - virtual int check_handles (void); - - /// Wait for events to occur. - virtual int wait_for_multiple_events (ACE_Select_Reactor_Handle_Set &, - ACE_Time_Value *); - - // = Dispatching methods. - - /** - * Template Method that dispatches ACE_Event_Handlers for time - * events, I/O events, and signal events. Returns the total number - * of ACE_Event_Handlers that were dispatched or -1 if something - * goes wrong. - */ - virtual int dispatch (int nfound, - ACE_Select_Reactor_Handle_Set &); - - /** - * Dispatch all timer handlers that have expired. Returns -1 if the - * state of the has changed, else 0. - * is set to the number of timer handlers - * dispatched. - */ - virtual int dispatch_timer_handlers (int &number_dispatched); - - /** - * Dispatch any notification handlers. Returns -1 if the state of - * the has changed, else returns number of handlers - * notified. - */ - virtual int dispatch_notification_handlers (ACE_Select_Reactor_Handle_Set &dispatch_set, - int &number_of_active_handles, - int &number_of_handlers_dispatched); - - /** - * Dispatch all the input/output/except handlers that are enabled in - * the @a dispatch_set. Updates @a number_of_active_handles and - * @a number_of_handlers_dispatched according to the behavior of the - * number Returns -1 if the state of the has changed, - * else 0. - */ - virtual int dispatch_io_handlers (ACE_Select_Reactor_Handle_Set &dispatch_set, - int &number_of_active_handles, - int &number_of_handlers_dispatched); - - /** - * Factors the dispatching of an io handle set (each WRITE, EXCEPT - * or READ set of handles). It updates the - * @a number_of_handlers_dispatched and invokes this->notify_handle - * for all the handles in using the @a mask, - * and @a callback parameters. Must return -1 if - * this->state_changed otherwise it must return 0. - */ - virtual int dispatch_io_set (int number_of_active_handles, - int &number_of_handlers_dispatched, - int mask, - ACE_Handle_Set& dispatch_mask, - ACE_Handle_Set& ready_mask, - ACE_EH_PTMF callback); - - /// Notify the appropriate @a callback in the context of the @a eh - /// associated with @a handle that a particular event has occurred. - virtual void notify_handle (ACE_HANDLE handle, - ACE_Reactor_Mask mask, - ACE_Handle_Set &, - ACE_Event_Handler *eh, - ACE_EH_PTMF callback); - - /// Enqueue ourselves into the list of waiting threads at the - /// appropriate point specified by . - virtual void renew (void); - - /// Synchronization token for the MT_SAFE ACE_Select_Reactor. - ACE_SELECT_REACTOR_TOKEN token_; - - /// Adapter used to return internal lock to outside world. - ACE_Lock_Adapter lock_adapter_; - - /// Release the token lock when a Win32 structured exception occurs. - int release_token (void); - - /// Stops the VC++ compiler from bitching about exceptions and destructors - int handle_events_i (ACE_Time_Value *max_wait_time = 0); - - /// This flag is used to keep track of whether we are actively handling - /// events or not. - sig_atomic_t deactivated_; - -private: - /// Deny access since member-wise won't work... - ACE_UNIMPLEMENTED_FUNC (ACE_Select_Reactor_T (const ACE_Select_Reactor_T &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Select_Reactor_T &operator= (const ACE_Select_Reactor_T &) ) -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Select_Reactor_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Select_Reactor_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Select_Reactor_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_SELECT_REACTOR_T_H */ diff --git a/deps/acelite/ace/Select_Reactor_T.inl b/deps/acelite/ace/Select_Reactor_T.inl deleted file mode 100644 index 7200933a4..000000000 --- a/deps/acelite/ace/Select_Reactor_T.inl +++ /dev/null @@ -1,231 +0,0 @@ -// -*- C++ -*- -#include "ace/Reactor.h" -#include "ace/Signal.h" -#include "ace/Sig_Handler.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_INLINE int -ACE_Select_Reactor_T::resume_handler (ACE_Event_Handler *h) -{ - ACE_TRACE ("ACE_Select_Reactor_T::resume_handler"); - return this->resume_handler (h->get_handle ()); -} - -template -ACE_INLINE int -ACE_Select_Reactor_T::resume_handler (const ACE_Handle_Set &handles) -{ - ACE_TRACE ("ACE_Select_Reactor_T::resume_handler"); - ACE_Handle_Set_Iterator handle_iter (handles); - ACE_HANDLE h; - - ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1)); - - while ((h = handle_iter ()) != ACE_INVALID_HANDLE) - if (this->resume_i (h) == -1) - return -1; - - return 0; -} - -template -ACE_INLINE int -ACE_Select_Reactor_T::suspend_handler (ACE_Event_Handler *h) -{ - ACE_TRACE ("ACE_Select_Reactor_T::suspend_handler"); - return this->suspend_handler (h->get_handle ()); -} - -template -ACE_INLINE int -ACE_Select_Reactor_T::suspend_handler (const ACE_Handle_Set &handles) -{ - ACE_TRACE ("ACE_Select_Reactor_T::suspend_handler"); - ACE_Handle_Set_Iterator handle_iter (handles); - ACE_HANDLE h; - - ACE_MT (ACE_GUARD_RETURN (ACE_SELECT_REACTOR_TOKEN, ace_mon, this->token_, -1)); - - while ((h = handle_iter ()) != ACE_INVALID_HANDLE) - if (this->suspend_i (h) == -1) - return -1; - - return 0; -} - -template -ACE_INLINE int -ACE_Select_Reactor_T::register_handler (int signum, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp, - ACE_Event_Handler **old_sh, - ACE_Sig_Action *old_disp) -{ - ACE_TRACE ("ACE_Select_Reactor_T::register_handler"); - return this->signal_handler_->register_handler (signum, - new_sh, new_disp, - old_sh, old_disp); -} - -#if defined (ACE_WIN32) -template -ACE_INLINE int -ACE_Select_Reactor_T::register_handler (ACE_Event_Handler *, - ACE_HANDLE ) -{ - // Don't have an implementation for this yet... - ACE_NOTSUP_RETURN (-1); -} -#endif /* ACE_WIN32 */ - -template -ACE_INLINE int -ACE_Select_Reactor_T::register_handler (ACE_HANDLE , - ACE_HANDLE , - ACE_Event_Handler *, - ACE_Reactor_Mask ) -{ - // Don't have an implementation for this yet... - ACE_NOTSUP_RETURN (-1); -} - -template -ACE_INLINE int -ACE_Select_Reactor_T::handler (int signum, ACE_Event_Handler **handler) -{ - ACE_TRACE ("ACE_Select_Reactor_T::handler"); - return this->handler_i (signum, handler); -} - -template -ACE_INLINE int -ACE_Select_Reactor_T::remove_handler (int signum, - ACE_Sig_Action *new_disp, - ACE_Sig_Action *old_disp, - int sigkey) -{ - ACE_TRACE ("ACE_Select_Reactor_T::remove_handler"); - return this->signal_handler_->remove_handler (signum, new_disp, old_disp, sigkey); -} - -template -ACE_INLINE bool -ACE_Select_Reactor_T::uses_event_associations (void) -{ - // Since the Select_Reactor does not do any event associations, this - // function always return false. - return false; -} - -// = The remaining methods in this file must be called with locks -// held. - -// Performs operations on the "ready" bits. - -template ACE_INLINE int -ACE_Select_Reactor_T::ready_ops (ACE_Event_Handler *handler, - ACE_Reactor_Mask mask, - int ops) -{ - ACE_TRACE ("ACE_Select_Reactor_T::ready_ops"); - return this->ready_ops (handler->get_handle (), mask, ops); -} - -// Performs operations on the "dispatch" masks. - -template ACE_INLINE int -ACE_Select_Reactor_T::mask_ops (ACE_Event_Handler *handler, - ACE_Reactor_Mask mask, - int ops) -{ - ACE_TRACE ("ACE_Select_Reactor_T::mask_ops"); - return this->mask_ops (handler->get_handle (), mask, ops); -} - -template ACE_INLINE int -ACE_Select_Reactor_T::schedule_wakeup (ACE_Event_Handler *eh, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Select_Reactor_T::schedule_wakeup"); - return this->mask_ops (eh->get_handle (), mask, ACE_Reactor::ADD_MASK); -} - -template ACE_INLINE int -ACE_Select_Reactor_T::cancel_wakeup (ACE_Event_Handler *eh, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Select_Reactor_T::cancel_wakeup"); - return this->mask_ops (eh->get_handle (), mask, ACE_Reactor::CLR_MASK); -} - -template ACE_INLINE int -ACE_Select_Reactor_T::schedule_wakeup (ACE_HANDLE handle, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Select_Reactor_T::schedule_wakeup"); - return this->mask_ops (handle, mask, ACE_Reactor::ADD_MASK); -} - -template ACE_INLINE int -ACE_Select_Reactor_T::cancel_wakeup (ACE_HANDLE handle, - ACE_Reactor_Mask mask) -{ - ACE_TRACE ("ACE_Select_Reactor_T::cancel_wakeup"); - return this->mask_ops (handle, mask, ACE_Reactor::CLR_MASK); -} - -template ACE_INLINE ACE_Lock & -ACE_Select_Reactor_T::lock (void) -{ - ACE_TRACE ("ACE_Select_Reactor_T::lock"); - return this->lock_adapter_; -} - -template ACE_INLINE void -ACE_Select_Reactor_T::wakeup_all_threads (void) -{ - // Send a notification, but don't block if there's no one to receive - // it. - this->notify (0, ACE_Event_Handler::NULL_MASK, (ACE_Time_Value *) &ACE_Time_Value::zero); -} - -template ACE_INLINE int -ACE_Select_Reactor_T::alertable_handle_events (ACE_Time_Value *max_wait_time) -{ - return this->handle_events (max_wait_time); -} - -template ACE_INLINE int -ACE_Select_Reactor_T::alertable_handle_events (ACE_Time_Value &max_wait_time) -{ - return this->handle_events (max_wait_time); -} - -template ACE_INLINE int -ACE_Select_Reactor_T::deactivated (void) -{ - return this->deactivated_; -} - -template ACE_INLINE void -ACE_Select_Reactor_T::deactivate (int do_stop) -{ - { - ACE_MT (ACE_GUARD (ACE_SELECT_REACTOR_TOKEN, - ace_mon, - this->token_)); - this->deactivated_ = static_cast (do_stop); - } - - this->wakeup_all_threads (); -} - -template ACE_INLINE size_t -ACE_Select_Reactor_T::size (void) const -{ - return this->handler_rep_.size (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Semaphore.cpp b/deps/acelite/ace/Semaphore.cpp deleted file mode 100644 index dcbac24fc..000000000 --- a/deps/acelite/ace/Semaphore.cpp +++ /dev/null @@ -1,61 +0,0 @@ -#include "ace/Semaphore.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Semaphore.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Log_Category.h" -#include "ace/ACE.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Semaphore) - -void -ACE_Semaphore::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Semaphore::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n"))); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Semaphore::ACE_Semaphore (unsigned int count, - int type, - const ACE_TCHAR *name, - void *arg, - int max) - : removed_ (false) -{ -// ACE_TRACE ("ACE_Semaphore::ACE_Semaphore"); -#if defined(ACE_LACKS_UNNAMED_SEMAPHORE) -// if the user does not provide a name, we generate a unique name here - ACE_TCHAR iname[ACE_UNIQUE_NAME_LEN]; - if (name == 0) - ACE::unique_name (this, iname, ACE_UNIQUE_NAME_LEN); - if (ACE_OS::sema_init (&this->semaphore_, count, type, - name ? name : iname, - arg, max) != 0) -#else - if (ACE_OS::sema_init (&this->semaphore_, count, type, - name, arg, max) != 0) -#endif - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Semaphore::ACE_Semaphore"))); -} - -ACE_Semaphore::~ACE_Semaphore (void) -{ -// ACE_TRACE ("ACE_Semaphore::~ACE_Semaphore"); - - this->remove (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Semaphore.h b/deps/acelite/ace/Semaphore.h deleted file mode 100644 index a8fc282fa..000000000 --- a/deps/acelite/ace/Semaphore.h +++ /dev/null @@ -1,180 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Semaphore.h - * - * Moved from Synch.h. - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_SEMAPHORE_H -#define ACE_SEMAPHORE_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/OS_NS_Thread.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Time_Value; - -/** - * @class ACE_Semaphore - * - * @brief Wrapper for Dijkstra style general semaphores. - */ -class ACE_Export ACE_Semaphore -{ -public: - /// Initialize the semaphore, with initial value of "count". - ACE_Semaphore (unsigned int count = 1, // By default make this unlocked. - int type = USYNC_THREAD, - const ACE_TCHAR *name = 0, - void * = 0, - int max = 0x7fffffff); - - /// Implicitly destroy the semaphore. - ~ACE_Semaphore (void); - - /** - * Explicitly destroy the semaphore. Note that only one thread - * should call this method since it doesn't protect against race - * conditions. - */ - int remove (void); - - /// Block the thread until the semaphore count becomes - /// greater than 0, then decrement it. - int acquire (void); - - /** - * Block the thread until the semaphore count becomes greater than 0 - * (at which point it is decremented) or until @a tv times out (in - * which case -1 is returned and @c errno == @c ETIME). Note that @a tv - * is assumed to be in "absolute" rather than "relative" time. The - * value of @a tv is updated upon return to show the actual - * (absolute) acquisition time. - * - * @note Solaris threads do not support timed semaphores. - * Therefore, if you're running on Solaris you might want to - * consider using the ACE POSIX pthreads implementation instead, - * which can be enabled by compiling ACE with - * -DACE_HAS_PTHREADS, rather than -DACE_HAS_STHREADS or - * -DACE_HAS_POSIX_SEM. - */ - int acquire (ACE_Time_Value &tv); - - /** - * If @a tv == 0 then call directly. Otherwise, Block - * the thread until the semaphore count becomes greater than 0 - * (at which point it is decremented) or until @a tv times out (in - * which case -1 is returned and @c errno == @c ETIME). Note that - * <*tv> is assumed to be in "absolute" rather than "relative" time. - * The value of <*tv> is updated upon return to show the actual - * (absolute) acquisition time. - * - * @note Solaris threads do not support timed semaphores. - * Therefore, if you're running on Solaris you might want to - * consider using the ACE POSIX pthreads implementation instead, - * which can be enabled by compiling ACE with - * -DACE_HAS_PTHREADS, rather than -DACE_HAS_STHREADS or - * -DACE_HAS_POSIX_SEM. */ - int acquire (ACE_Time_Value *tv); - - /** - * Conditionally decrement the semaphore if count is greater than 0 - * (i.e., won't block). Returns -1 on failure. If we "failed" - * because someone else already had the lock, @c errno is set to - * @c EBUSY. - */ - int tryacquire (void); - - /// Increment the semaphore by 1, potentially unblocking a waiting - /// thread. - int release (void); - - /// Increment the semaphore by @a release_count, potentially - /// unblocking waiting threads. - int release (unsigned int release_count); - - /** - * Acquire semaphore ownership. This calls and is only - * here to make the ACE_Semaphore interface consistent with the - * other synchronization APIs. - */ - int acquire_read (void); - - /** - * Acquire semaphore ownership. This calls and is only - * here to make the ACE_Semaphore interface consistent with the - * other synchronization APIs. - */ - int acquire_write (void); - - /** - * Conditionally acquire semaphore (i.e., won't block). This calls - * and is only here to make the ACE_Semaphore - * interface consistent with the other synchronization APIs. - * Returns -1 on failure. If we "failed" because someone else - * already had the lock, @c errno is set to @c EBUSY. - */ - int tryacquire_read (void); - - /** - * Conditionally acquire semaphore (i.e., won't block). This calls - * and is only here to make the ACE_Semaphore - * interface consistent with the other synchronization APIs. - * Returns -1 on failure. If we "failed" because someone else - * already had the lock, @c errno is set to @c EBUSY. - */ - int tryacquire_write (void); - - /** - * This is only here to make the ACE_Semaphore - * interface consistent with the other synchronization APIs. - * Assumes the caller has already acquired the semaphore using one of - * the above calls, and returns 0 (success) always. - */ - int tryacquire_write_upgrade (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - /// Return the underlying lock. - const ACE_sema_t &lock (void) const; - -protected: - ACE_sema_t semaphore_; - - /// Keeps track of whether remove() has been called yet to avoid - /// multiple remove() calls, e.g., explicitly and implicitly in the - /// destructor. This flag isn't protected by a lock, so make sure - /// that you don't have multiple threads simultaneously calling - /// remove () on the same object, which is a bad idea anyway... - bool removed_; - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Semaphore &); - ACE_Semaphore (const ACE_Semaphore &); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Semaphore.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_SEMAPHORE_H */ diff --git a/deps/acelite/ace/Semaphore.inl b/deps/acelite/ace/Semaphore.inl deleted file mode 100644 index 8de0beef3..000000000 --- a/deps/acelite/ace/Semaphore.inl +++ /dev/null @@ -1,116 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE const ACE_sema_t & -ACE_Semaphore::lock (void) const -{ -// ACE_TRACE ("ACE_Semaphore::lock"); - return this->semaphore_; -} - -ACE_INLINE int -ACE_Semaphore::remove (void) -{ -// ACE_TRACE ("ACE_Semaphore::remove"); - int result = 0; - if (!this->removed_) - { - this->removed_ = true; - result = ACE_OS::sema_destroy (&this->semaphore_); - } - return result; -} - -ACE_INLINE int -ACE_Semaphore::acquire (void) -{ -// ACE_TRACE ("ACE_Semaphore::acquire"); - return ACE_OS::sema_wait (&this->semaphore_); -} - -ACE_INLINE int -ACE_Semaphore::acquire (ACE_Time_Value &tv) -{ -// ACE_TRACE ("ACE_Semaphore::acquire"); - return ACE_OS::sema_wait (&this->semaphore_, tv); -} - -ACE_INLINE int -ACE_Semaphore::acquire (ACE_Time_Value *tv) -{ -// ACE_TRACE ("ACE_Semaphore::acquire"); - return ACE_OS::sema_wait (&this->semaphore_, tv); -} - -ACE_INLINE int -ACE_Semaphore::tryacquire (void) -{ -// ACE_TRACE ("ACE_Semaphore::tryacquire"); - return ACE_OS::sema_trywait (&this->semaphore_); -} - -ACE_INLINE int -ACE_Semaphore::release (void) -{ -// ACE_TRACE ("ACE_Semaphore::release"); - return ACE_OS::sema_post (&this->semaphore_); -} - -ACE_INLINE int -ACE_Semaphore::release (unsigned int release_count) -{ -// ACE_TRACE ("ACE_Semaphore::release"); - return ACE_OS::sema_post (&this->semaphore_, release_count); -} - -// Acquire semaphore ownership. This calls and is only -// here to make the interface consistent with the -// other synchronization APIs. - -ACE_INLINE int -ACE_Semaphore::acquire_read (void) -{ - return this->acquire (); -} - -// Acquire semaphore ownership. This calls and is only -// here to make the interface consistent with the -// other synchronization APIs. - -ACE_INLINE int -ACE_Semaphore::acquire_write (void) -{ - return this->acquire (); -} - -// Conditionally acquire semaphore (i.e., won't block). This calls -// and is only here to make the -// interface consistent with the other synchronization APIs. - -ACE_INLINE int -ACE_Semaphore::tryacquire_read (void) -{ - return this->tryacquire (); -} - -// Conditionally acquire semaphore (i.e., won't block). This calls -// and is only here to make the -// interface consistent with the other synchronization APIs. - -ACE_INLINE int -ACE_Semaphore::tryacquire_write (void) -{ - return this->tryacquire (); -} - -// This is only here to make the interface consistent -// with the other synchronization APIs. Assumes the caller has -// already acquired the semaphore using one of the above calls, and -// returns 0 (success) always. -ACE_INLINE int -ACE_Semaphore::tryacquire_write_upgrade (void) -{ - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Service_Config.cpp b/deps/acelite/ace/Service_Config.cpp deleted file mode 100644 index 193e54ab8..000000000 --- a/deps/acelite/ace/Service_Config.cpp +++ /dev/null @@ -1,615 +0,0 @@ -#include "ace/Service_Config.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Service_Config.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Service_Types.h" -#include "ace/Reactor.h" -#include "ace/Singleton.h" -#include "ace/Service_Repository.h" - -#ifndef ACE_LACKS_UNIX_SIGNALS -# include "ace/Sig_Adapter.h" -#endif /* !ACE_LACKS_UNIX_SIGNALS */ - -#include "ace/OS_NS_time.h" -#include "ace/OS_NS_stdio.h" -#include "ace/OS_NS_unistd.h" -#include "ace/Thread.h" -#include "ace/Get_Opt.h" -#include "ace/ARGV.h" -#include "ace/Log_Category.h" -#include "ace/ACE.h" - -#ifdef ACE_HAS_TSS_EMULATION -#include "ace/Object_Manager.h" -#endif - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Threading_Helper::~ACE_Threading_Helper (void) -{ - ACE_OS::thr_key_detach (this->key_); - ACE_OS::thr_keyfree (this->key_); -} - -ACE_Threading_Helper::ACE_Threading_Helper (void) - : key_ (ACE_OS::NULL_key) -{ -# if defined (ACE_HAS_TSS_EMULATION) - ACE_Object_Manager::init_tss (); -# endif - - if (ACE_Thread::keycreate (&key_, 0) == -1) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("(%P|%t) Failed to create thread key: %p\n"), - ACE_TEXT (""))); - } -} - -void -ACE_Threading_Helper::set (void* p) -{ - if (ACE_Thread::setspecific (key_, p) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("(%P|%t) Service Config failed to set thread key value: %p\n"), - ACE_TEXT(""))); -} - -void* -ACE_Threading_Helper::get (void) -{ - void* temp = 0; - if (ACE_Thread::getspecific (key_, &temp) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("(%P|%t) Service Config failed to get thread key value: %p\n"), - ACE_TEXT("")), - 0); - return temp; -} - -ACE_Threading_Helper::~ACE_Threading_Helper () -{ -} - -ACE_Threading_Helper::ACE_Threading_Helper () -{ -} - -void -ACE_Threading_Helper::set (void*) -{ -} - -void* -ACE_Threading_Helper::get (void) -{ - return ACE_Service_Config::singleton()->instance_.get (); -} - -/** - * @c ACE_Service_Config is supposed to be a Singleton. This is the - * only Configuration Gestalt available for access from static - * initializers at proces start-up time. Using Unmanaged Singleton - * is safer because (a) the Object Manager may not yet be fully initialized - * in the context of a static initializer that uses SC, and (b) because we - * know that upon process exit the SC will still be automaticaly and explicitly - * closed by @c ACE_Object_Manager::fini(). - */ -typedef ACE_Unmanaged_Singleton ACE_SERVICE_CONFIG_SINGLETON; - - -/// ctor -ACE_Service_Config_Guard::ACE_Service_Config_Guard (ACE_Service_Gestalt * psg) - : saved_ (ACE_Service_Config::current ()) -{ - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) - SCG:") - ACE_TEXT (" - config=%@ repo=%@ superseded by repo=%@\n"), - this, - this->saved_.get (), - this->saved_->repo_, - psg->repo_)); - - // Modify the TSS if the repo has changed - ACE_Service_Config::current (psg); -} - -ACE_Service_Config_Guard::~ACE_Service_Config_Guard (void) -{ - ACE_Service_Gestalt* s = this->saved_.get (); - ACE_ASSERT (s != 0); - - ACE_Service_Config::current (s); - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SCG:") - ACE_TEXT (" - new repo=%@\n"), - this, - this->saved_->repo_)); -} - - -ACE_ALLOC_HOOK_DEFINE (ACE_Service_Config) - -// Set the signal handler to point to the handle_signal() function. -ACE_Sig_Adapter *ACE_Service_Config::signal_handler_ = 0; - -// Trigger a reconfiguration. -sig_atomic_t ACE_Service_Config::reconfig_occurred_ = 0; - -// = Set by command-line options. - -/// Pathname of file to write process id. -ACE_TCHAR *ACE_Service_Config::pid_file_name_ = 0; - -/// Shall we become a daemon process? -bool ACE_Service_Config::be_a_daemon_ = false; - -/// Number of the signal used to trigger reconfiguration. -int ACE_Service_Config::signum_ = SIGHUP; - -void -ACE_Service_Config::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Service_Config::dump"); -#endif /* ACE_HAS_DUMP */ -} - -int -ACE_Service_Config::parse_args_i (int argc, ACE_TCHAR *argv[]) -{ - ACE_TRACE ("ACE_Service_Config::parse_args_i"); - - // Using PERMUTE_ARGS (default) in order to have all - // unrecognized options and their value arguments moved - // to the end of the argument vector. We'll pick them up - // after processing our options and pass them on to the - // base class for further parsing. - //FUZZ: disable check_for_lack_ACE_OS - ACE_Get_Opt getopt (argc, - argv, - ACE_TEXT ("bs:p:"), - 1 , // Start at argv[1]. - 0, // Do not report errors - ACE_Get_Opt::RETURN_IN_ORDER); - //FUZZ: enable check_for_lack_ACE_OS - - //FUZZ: disable check_for_lack_ACE_OS - for (int c; (c = getopt ()) != -1; ) - //FUZZ: enable check_for_lack_ACE_OS - switch (c) - { - case 'p': - ACE_Service_Config::pid_file_name_ = getopt.opt_arg (); - break; - case 'b': - ACE_Service_Config::be_a_daemon_ = true; - break; - case 's': - { - // There's no point in dealing with this on NT since it - // doesn't really support signals very well... -#if !defined (ACE_LACKS_UNIX_SIGNALS) - ACE_Service_Config::signum_ = - ACE_OS::atoi (getopt.opt_arg ()); - - if (ACE_Reactor::instance ()->register_handler - (ACE_Service_Config::signum_, - ACE_Service_Config::signal_handler_) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("cannot obtain signal handler\n")), - -1); -#endif /* ACE_LACKS_UNIX_SIGNALS */ - break; - } - default:; // unknown arguments are benign - - } - - return 0; -} /* parse_args_i () */ - - -int -ACE_Service_Config::open_i (const ACE_TCHAR program_name[], - const ACE_TCHAR *logger_key, - bool , - bool , - bool ) -{ - ACE_TRACE ("ACE_Service_Config::open_i"); - ACE_MT (ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, ace_mon, this->lock_, -1)); - - ACE_Log_Msg *log_msg = ACE_LOG_MSG; - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SC::open_i - this=%@, opened=%d\n"), - this, this->is_opened_)); - - // Guard against reentrant processing. - if (this->is_opened_) - return 0; - - this->is_opened_ = true; - - // Check for things we need to do on a per-process basis and which - // may not be safe, or wise to do an a per instance basis - - // Become a daemon before doing anything else. - if (ACE_Service_Config::be_a_daemon_) - { - // If we have to become a daemn and that fails - // return -1 here - if (ACE::daemonize () == -1) - return -1; - } - - // Write process id to file. - if (this->pid_file_name_ != 0) - { - FILE* pidf = ACE_OS::fopen (this->pid_file_name_, - ACE_TEXT("w")); - - if (pidf != 0) - { - ACE_OS::fprintf (pidf, - "%ld\n", - static_cast (ACE_OS::getpid())); - ACE_OS::fclose (pidf); - } - } - - u_long flags = log_msg->flags (); - - // Only use STDERR if the caller hasn't already set the flags. - if (flags == 0) - flags = (u_long) ACE_Log_Msg::STDERR; - - const ACE_TCHAR *key = logger_key; - - if (key == 0 || ACE_OS::strcmp (key, ACE_DEFAULT_LOGGER_KEY) == 0) - { - // Only use the static if the caller doesn't - // override it in the parameter list or if the key supplied is - // equal to the default static logger key. - key = ACE_Service_Config::current()->logger_key_; - } - else - { - ACE_SET_BITS (flags, ACE_Log_Msg::LOGGER); - } - - if (log_msg->open (program_name, - flags, - key) == -1) - return -1; - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_STARTUP, - ACE_TEXT ("starting up daemon %n\n"))); - - // Initialize the Service Repository (this will still work if - // user forgets to define an object of type ACE_Service_Config). - ACE_Service_Repository::instance (ACE_Service_Gestalt::MAX_SERVICES); - - // Initialize the ACE_Reactor (the ACE_Reactor should be the - // same size as the ACE_Service_Repository). - ACE_Reactor::instance (); - - // There's no point in dealing with this on NT since it doesn't - // really support signals very well... -#if !defined (ACE_LACKS_UNIX_SIGNALS) - // Only attempt to register a signal handler for positive - // signal numbers. - if (ACE_Service_Config::signum_ > 0) - { - ACE_Sig_Set ss; - ss.sig_add (ACE_Service_Config::signum_); - if ((ACE_Reactor::instance () != 0) && - (ACE_Reactor::instance ()->register_handler - (ss, ACE_Service_Config::signal_handler_) == -1)) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("can't register signal handler\n"))); - } -#endif /* ACE_LACKS_UNIX_SIGNALS */ - - return 0; -} - -/// Return the global configuration instance. Always returns the same -/// instance -ACE_Service_Config * -ACE_Service_Config::singleton (void) -{ - return ACE_SERVICE_CONFIG_SINGLETON::instance (); -} - -int -ACE_Service_Config::insert (ACE_Static_Svc_Descriptor* stsd) -{ - return ACE_Service_Config::instance ()->insert (stsd); -} - - -// Totally remove from the daemon by removing it from the -// ACE_Reactor, and unlinking it if necessary. -int -ACE_Service_Config::remove (const ACE_TCHAR svc_name[]) -{ - ACE_TRACE ("ACE_Service_Config::remove"); - return ACE_Service_Repository::instance ()->remove (svc_name); -} - -// Suspend . Note that this will not unlink the service -// from the daemon if it was dynamically linked, it will mark it as -// being suspended in the Service Repository and call the -// member function on the appropriate . A service -// can be resumed later on by calling the method... - -int -ACE_Service_Config::suspend (const ACE_TCHAR svc_name[]) -{ - ACE_TRACE ("ACE_Service_Config::suspend"); - return ACE_Service_Repository::instance ()->suspend (svc_name); -} - -// Resume a SVC_NAME that was previously suspended or has not yet -// been resumed (e.g., a static service). - -int -ACE_Service_Config::resume (const ACE_TCHAR svc_name[]) -{ - ACE_TRACE ("ACE_Service_Config::resume"); - return ACE_Service_Repository::instance ()->resume (svc_name); -} - - -ACE_Service_Config::ACE_Service_Config (bool ignore_static_svcs, - size_t size, - int signum) -{ - ACE_TRACE ("ACE_Service_Config::ACE_Service_Config"); - - // TODO: Need to find a more customizable way of instantiating the - // gestalt but perhaps we should leave this out untill such - // customizations are identified. - ACE_Service_Gestalt* tmp = 0; - ACE_NEW_NORETURN (tmp, - ACE_Service_Gestalt (size, false, ignore_static_svcs)); - - this->is_opened_ = false; - this->instance_ = tmp; - this->threadkey_.set (tmp); - - ACE_Service_Config::signum_ = signum; -} - -ACE_Service_Config::ACE_Service_Config (const ACE_TCHAR program_name[], - const ACE_TCHAR *logger_key) -{ - ACE_TRACE ("ACE_Service_Config::ACE_Service_Config"); - - // TODO: Need to find a more customizable way of instantiating the - // gestalt but perhaps we should leave this out untill such - // customizations are identified. - ACE_Service_Gestalt* tmp = 0; - ACE_NEW_NORETURN (tmp, - ACE_Service_Gestalt (ACE_Service_Repository::DEFAULT_SIZE, false)); - - this->is_opened_ = false; - this->instance_ = tmp; - this->threadkey_.set (tmp); - - if (this->open (program_name, - logger_key) == -1 && errno != ENOENT) - { - // Only print out an error if it wasn't the svc.conf file that was - // missing. - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("(%P|%t) SC failed to open: %p\n"), - program_name)); - } -} - -/// Return the "global" configuration instance, for the current -/// thread. This may be the same as instance(), but on some occasions, -/// it may be a different one. For example, ACE_Service_Config_Guard -/// provides a way of temporarily replacing the "current" -/// configuration instance in the context of a thread. -ACE_Service_Gestalt* -ACE_Service_Config::current (void) -{ - void* temp = ACE_Service_Config::singleton()->threadkey_.get (); - if (temp == 0) { - - // The most likely reason is that the current thread was spawned - // by some native primitive, like pthreads or Windows API - not - // from ACE. This is perfectly legal for callers who are not, or - // do not need to be ACE-aware. Such callers must have no - // expectation that the pluggable, multi-context configuration - // support will work - they would always get the global context, - // because at this point there is no information what the "parent" - // thread's configuration context was. - - temp = global(); - singleton()->threadkey_.set (temp); - } - - return static_cast (temp); -} - -/// A mutator to set the "current" (TSS) gestalt instance. -void -ACE_Service_Config::current (ACE_Service_Gestalt* newcurrent) -{ - ACE_Service_Config::singleton()->threadkey_.set (newcurrent); -} - - - -#if (ACE_USES_CLASSIC_SVC_CONF == 0) -ACE_Service_Type * -ACE_Service_Config::create_service_type (const ACE_TCHAR *n, - ACE_Service_Type_Impl *o, - ACE_DLL &dll, - int active) -{ - ACE_Service_Type *sp = 0; - ACE_NEW_RETURN (sp, - ACE_Service_Type (n, o, dll, active), - 0); - return sp; -} -#endif /* ACE_USES_CLASSIC_SVC_CONF == 0 */ - -ACE_Service_Type_Impl * -ACE_Service_Config::create_service_type_impl (const ACE_TCHAR *name, - int type, - void *symbol, - u_int flags, - ACE_Service_Object_Exterminator gobbler) -{ - ACE_Service_Type_Impl *stp = 0; - - // Note, the only place we need to put a case statement. This is - // also the place where we'd put the RTTI tests, if the compiler - // actually supported them! - - switch (type) - { - case ACE_Service_Type::SERVICE_OBJECT: - ACE_NEW_RETURN (stp, - ACE_Service_Object_Type ((ACE_Service_Object *) symbol, - name, flags, - gobbler), - 0); - break; - case ACE_Service_Type::MODULE: - ACE_NEW_RETURN (stp, - ACE_Module_Type (symbol, name, flags), - 0); - break; - case ACE_Service_Type::STREAM: - ACE_NEW_RETURN (stp, - ACE_Stream_Type (symbol, name, flags), - 0); - break; - default: - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("unknown case\n"))); - break; - } - return stp; - -} - - -// Signal handling API to trigger dynamic reconfiguration. -void -ACE_Service_Config::handle_signal (int sig, - siginfo_t *, - ucontext_t *) -{ -#if defined (ACE_NDEBUG) - ACE_UNUSED_ARG (sig); -#else /* ! ACE_NDEBUG */ - ACE_ASSERT (ACE_Service_Config::signum_ == sig); -#endif /* ! ACE_NDEBUG */ - - ACE_Service_Config::reconfig_occurred_ = 1; -} - -// Trigger reconfiguration to re-read configuration files. -void -ACE_Service_Config::reconfigure (void) -{ - ACE_TRACE ("ACE_Service_Config::reconfigure"); - - ACE_Service_Config::reconfig_occurred_ = 0; - - if (ACE::debug ()) - { -#if !defined (ACE_NLOGGING) - time_t t = ACE_OS::time (0); - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("beginning reconfiguration at %s"), - ACE_OS::ctime (&t))); -#endif /* ! ACE_NLOGGING */ - } - if (ACE_Service_Config::process_directives () == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("process_directives"))); -} - -// Tidy up and perform last rites on a terminating ACE_Service_Config. -int -ACE_Service_Config::close (void) -{ - ACE_Service_Config::singleton ()->instance_->close (); - - // Delete the service repository. All the objects inside the - // service repository should already have been finalized. - ACE_Service_Repository::close_singleton (); - - // Do away with the singleton ACE_Service_Config (calls dtor) - ACE_SERVICE_CONFIG_SINGLETON::close (); - - return 0; -} - - -int -ACE_Service_Config::fini_svcs (void) -{ - ACE_TRACE ("ACE_Service_Config::fini_svcs"); - - // Clear the LM_DEBUG bit from log messages if appropriate - if (ACE::debug ()) - ACE_Log_Msg::disable_debug_messages (); - - int result = 0; - if (ACE_Service_Repository::instance () != 0) - result = ACE_Service_Repository::instance ()->fini (); - - if (ACE::debug ()) - ACE_Log_Msg::enable_debug_messages (); - - return result; -} - -/// Perform user-specified close activities and remove dynamic memory. -ACE_Service_Config::~ACE_Service_Config (void) -{ - ACE_TRACE ("ACE_Service_Config::~ACE_Service_Config"); -} - -// ************************************************************ - -/* static */ -int -ACE_Service_Config::reconfig_occurred (void) -{ - ACE_TRACE ("ACE_Service_Config::reconfig_occurred"); - return ACE_Service_Config::reconfig_occurred_ != 0; -} - -void -ACE_Service_Config::reconfig_occurred (int config_occurred) -{ - ACE_TRACE ("ACE_Service_Config::reconfig_occurred"); - ACE_Service_Config::reconfig_occurred_ = - static_cast (config_occurred); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Service_Config.h b/deps/acelite/ace/Service_Config.h deleted file mode 100644 index ac9d44df6..000000000 --- a/deps/acelite/ace/Service_Config.h +++ /dev/null @@ -1,745 +0,0 @@ -// -*- C++ -*- - -//==================================================================== -/** - * @file Service_Config.h - * - * @author Douglas C. Schmidt - */ -//==================================================================== - -#ifndef ACE_SERVICE_CONFIG_H -#define ACE_SERVICE_CONFIG_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" -#include "ace/Default_Constants.h" -#include "ace/Intrusive_Auto_Ptr.h" -#include "ace/Service_Gestalt.h" -#include "ace/Synch_Traits.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/OS_NS_signal.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward decl. -class ACE_Service_Object; -class ACE_Service_Type; -class ACE_Service_Type_Impl; -class ACE_Service_Repository; -class ACE_Sig_Adapter; -class ACE_Allocator; -class ACE_Reactor; -class ACE_Thread_Manager; -class ACE_DLL; - -#if (ACE_USES_CLASSIC_SVC_CONF == 1) -#define ACE_STATIC_SERVICE_DIRECTIVE(ident, parameters) \ - ACE_TEXT ("static ") \ - ACE_TEXT (ident) \ - ACE_TEXT (" \"") \ - ACE_TEXT (parameters) \ - ACE_TEXT ("\"") -#define ACE_DYNAMIC_SERVICE_DIRECTIVE(ident, libpathname, objectclass, parameters) \ - ACE_TEXT ("dynamic ") \ - ACE_TEXT (ident) \ - ACE_TEXT (" Service_Object * ") \ - ACE_TEXT (libpathname) \ - ACE_TEXT (":") \ - ACE_TEXT (objectclass) \ - ACE_TEXT ("() \"") \ - ACE_TEXT (parameters) \ - ACE_TEXT ("\"") -#if defined (ACE_VERSIONED_SO) && (ACE_VERSIONED_SO == 2) -#define ACE_DYNAMIC_VERSIONED_SERVICE_DIRECTIVE(ident, libpathname, version, objectclass, parameters) \ - ACE_TEXT ("dynamic ") \ - ACE_TEXT (ident) \ - ACE_TEXT (" Service_Object * ") \ - ACE_DLL_PREFIX \ - ACE_TEXT (libpathname) \ - ACE_TEXT ("-") \ - ACE_TEXT (version) \ - ACE_DLL_SUFFIX \ - ACE_TEXT (":") \ - ACE_TEXT (objectclass) \ - ACE_TEXT ("() \"") \ - ACE_TEXT (parameters) \ - ACE_TEXT ("\"") -#else -#define ACE_DYNAMIC_VERSIONED_SERVICE_DIRECTIVE(ident, libpathname, version, objectclass, parameters) \ - ACE_TEXT ("dynamic ") \ - ACE_TEXT (ident) \ - ACE_TEXT (" Service_Object * ") \ - ACE_TEXT (libpathname) \ - ACE_TEXT (":") \ - ACE_TEXT (objectclass) \ - ACE_TEXT ("() \"") \ - ACE_TEXT (parameters) \ - ACE_TEXT ("\"") -#endif /* ACE_VERSIONED_SO */ -#define ACE_REMOVE_SERVICE_DIRECTIVE(ident) \ - ACE_TEXT ("remove ") \ - ACE_TEXT (ident) -class ACE_Svc_Conf_Param; -#else -#define ACE_STATIC_SERVICE_DIRECTIVE(ident, parameters) \ - ACE_TEXT ("") -#define ACE_DYNAMIC_SERVICE_DIRECTIVE(ident, libpathname, objectclass, parameters) \ - ACE_TEXT ("") \ - ACE_TEXT ("") -#if defined (ACE_VERSIONED_SO) && (ACE_VERSIONED_SO == 2) -#define ACE_DYNAMIC_VERSIONED_SERVICE_DIRECTIVE(ident, libpathname, version, objectclass, parameters) \ - ACE_TEXT ("") \ - ACE_TEXT ("") -#else -#define ACE_DYNAMIC_VERSIONED_SERVICE_DIRECTIVE(ident, libpathname, version, objectclass, parameters) \ - ACE_TEXT ("") \ - ACE_TEXT ("") -#endif -#define ACE_REMOVE_SERVICE_DIRECTIVE(ident) \ - ACE_TEXT ("") -class ACE_XML_Svc_Conf; -#endif /* ACE_USES_CLASSIC_SVC_CONF == 1 */ - -ACE_END_VERSIONED_NAMESPACE_DECL - -extern "C" -{ - typedef ACE_Service_Object *(*ACE_SERVICE_ALLOCATOR) (ACE_Service_Object_Exterminator *); -} - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Static_Svc_Descriptor - * - * @brief Holds the information necessary to describe a statically linked - * Svc. - */ -class ACE_Static_Svc_Descriptor -{ -public: - /// Name of the service. - const ACE_TCHAR *name_; - - /// Type of service. - int type_; - - /// Factory function that allocates the service. - ACE_SERVICE_ALLOCATOR alloc_; - - /// Bitmask flags indicating how the framework should delete memory. - u_int flags_; - - /// Flag indicating whether the service starts out active. - int active_; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -public: - /// Compare two service descriptors for equality. - bool operator== (ACE_Static_Svc_Descriptor &) const; - - /// Compare two service descriptors for inequality. - bool operator!= (ACE_Static_Svc_Descriptor &) const; -}; - - -/** - * @class ACE_Threading_Helper - * - * @brief Encapsulates responsibility for allocating, destroying and - * manipulating the value, associated with a thread-specific - * key. Relates to the ability of the created thread to inherit the - * parent thread's gestalt. Designed to be used as an instance member - * of @c ACE_Service_Config. - * - * Partial specialization over ACE_SYNCH_MUTEX is used to implement - * specific behavior in both multi- and single-threaded builds. - */ -template -class ACE_Threading_Helper -{ -}; - -/* - * Specialization for a multi threaded program - */ -template<> -class ACE_Export ACE_Threading_Helper -{ -public: - ACE_Threading_Helper (void); - ~ACE_Threading_Helper (void); - - void set (void*); - void* get (void); - -private: - /// Key for the thread-specific data, which is a simple pointer to - /// the thread's (currently-) global configuration context. - ACE_thread_key_t key_; -}; - -/* - * Specialization for a single threaded program - */ -template<> -class ACE_Export ACE_Threading_Helper -{ -public: - ACE_Threading_Helper (void); - ~ACE_Threading_Helper (void); - - void set (void*); - void* get (void); -}; - -#define ACE_Component_Config ACE_Service_Config - -/** - * @class ACE_Service_Config - * - * @brief Supplies common server operations for dynamic and static - * configuration of service. - * - * The ACE_Service_Config uses the Monostate pattern. Therefore, - * you can only have one of these instantiated per-process. It - * represents the process-wide collection of services, which is - * typically shared among all other configurable entities. The only - * ACE_Service_Config instance is registered with and owned by the - * ACE_Object_Manager. - * - * By contrast, the ACE_Service_Gestalt represents the collection - * of services, pertaining to a configurable entity. Typically, a - * "configurable entity" is an instance, which owns an instance of - * ACE_Service_Gestalt in order to ensure full control over the - * services it needs. - * - * Another facet of ACE_Service_Config is that for a given thread, - * it provides access to its current, process-global - * ACE_Service_Gestalt instance through its current() method. - * - * @note The signal_handler_ static member is allocated by the - * ACE_Object_Manager. The ACE_Service_Config constructor - * uses signal_handler_. Therefore, if the program has any - * static ACE_Service_Config objects, there might be - * initialization order problems. They can be minimized, but - * not eliminated, by _not_ #defining - * ACE_HAS_NONSTATIC_OBJECT_MANAGER. - */ -class ACE_Export ACE_Service_Config -{ - - /// The Instance, or the global (default) configuration context. - /// The monostate would forward the calls to that instance. The TSS - /// will point here - ACE_Intrusive_Auto_Ptr instance_; - - /// A helper instance to manage thread-specific key creation. - /// Dependent on the syncronization mutex ACE uses, the corresponding - /// partial template instantiation will perform the right services - /// that have to do with managing thread-specific storage. Note that, - /// for single-threaded builds they would do (next to) nothing. - ACE_Threading_Helper threadkey_; - -public: - /** - * Initialize the Service Repository. Note that initialising @a - * signum to a negative number will prevent a signal handler being - * registered when the repository is opened. - */ - ACE_Service_Config (bool ignore_static_svcs = true, - size_t size = ACE_DEFAULT_SERVICE_REPOSITORY_SIZE, - int signum = SIGHUP); - - /** - * Performs an open without parsing command-line arguments. The - * @a logger_key indicates where to write the logging output, which - * is typically either a STREAM pipe or a socket address. - */ - ACE_Service_Config (const ACE_TCHAR program_name[], - const ACE_TCHAR *logger_key = ACE_DEFAULT_LOGGER_KEY); - - /// Perform user-specified close activities and remove dynamic - /// memory. - virtual ~ACE_Service_Config (void); - -private: - - /** - * Performs an open without parsing command-line arguments. - * Implements whats different in the opening sequence - * for this class, as opposed to the base class. - * - * The @a logger_key indicates where to write the logging output, which - * is typically either a STREAM pipe or a socket address. If - * @a ignore_default_svc_conf_file is non-0 then the "svc.conf" file - * will be ignored. If @a ignore_debug_flag is non-0 then the - * application is responsible for setting the - * @c ACE_Log_Msg::priority_mask() appropriately. Returns number of - * errors that occurred on failure and 0 otherwise. - */ - virtual int open_i (const ACE_TCHAR program_name[], - const ACE_TCHAR *logger_key, - bool ignore_static_svcs, - bool ignore_default_svc_conf_file, - bool ignore_debug_flag); - - /** - * Implements whats different in the command line parameter processing - * for this class, as opposed to the base class. - */ - virtual int parse_args_i (int argc, ACE_TCHAR *argv[]); - - /// = Static interfaces - - public: - /** - * Returns the process-wide global singleton instance. It would - * have been created and will be managed by the Object Manager. - */ - static ACE_Service_Config* singleton (void); - - /** - * Mutator for the currently active configuration context instance - * (gestalt). Intended for use by helper classes like @see - * ACE_Service_Config_Guard. Stack-based instances can be used to - * temporarily change which gestalt is seen as global by static - * initializers (especially those in DLLs loaded at run-time). - */ - static void current (ACE_Service_Gestalt*); - - /** - * Accessor for the "current" service gestalt - */ - static ACE_Service_Gestalt* current (void); - - /** - * This is what the static service initializators are hard-wired to - * use, so in order to avoid interface changes this method merely - * forwards to @c ACE_Service_Config::current. This enables us to - * enforce which Service Gestalt is used for services registering - * through static initializers. Especially important for DLL-based - * dynamic services, which can contain their own static services and - * static initializers. - * - * @deprecated Use current() instead. - */ - static ACE_Service_Gestalt* instance (void); - - /** - * Returns a process-wide global singleton instance in contrast with - * current (), which may return a different instance at different - * times, dependent on the context. Modifying this method's return - * value is strongly discouraged as it will circumvent the mechanism - * for dynamically loading services. If you must, use with extreme - * caution! - */ - static ACE_Service_Gestalt* global (void); - - /** - * Performs an open without parsing command-line arguments. The - * @a logger_key indicates where to write the logging output, which - * is typically either a STREAM pipe or a socket address. If - * @a ignore_static_svcs is true then static services are not loaded, - * otherwise, they are loaded. If @a ignore_default_svc_conf_file is - * non-0 then the configuration file will be ignored. - * Returns zero upon success, -1 if the file is not found or cannot - * be opened (errno is set accordingly), otherwise returns the - * number of errors encountered loading the services in the - * specified svc.conf configuration file. If @a ignore_debug_flag is - * non-0 then the application is responsible for setting the - * @c ACE_Log_Msg::priority_mask appropriately. - */ - static int open (const ACE_TCHAR program_name[], - const ACE_TCHAR *logger_key = ACE_DEFAULT_LOGGER_KEY, - bool ignore_static_svcs = true, - bool ignore_default_svc_conf_file = false, - bool ignore_debug_flag = false); - - /** - * This is the primary entry point into the ACE_Service_Config (the - * constructor just handles simple initializations). It parses - * arguments passed in from @a argc and @a argv parameters. The - * arguments that are valid in a call to this method include: - * - * - '-b' Option to indicate that we should be a daemon. Note that when - * this option is used, the process will be daemonized before the - * service configuration file(s) are read. During daemonization, - * (on POSIX systems) the current directory will be changed to "/" - * so the caller should either fully specify the file names, or - * execute a @c chroot() to the appropriate directory. - * @sa ACE::daemonize(). - * - '-d' Turn on debugging mode - * - '-f' Specifies a configuration file name other than the default - * svc.conf. Can be specified multiple times to use multiple files. - * If any configuration file is provided with this option then - * the default svc.conf will be ignored. - * - '-k' Specifies the rendezvous point to use for the ACE distributed - * logger. - * - '-y' Explicitly enables the use of static services. This flag - * overrides the @a ignore_static_svcs parameter value. - * - '-n' Explicitly disables the use of static services. This flag - * overrides the @a ignore_static_svcs parameter value. - * - '-p' Specifies a pathname which is used to store the process id. - * - '-s' Specifies a signal number other than SIGHUP to trigger reprocessing - * of the configuration file(s). Ignored for platforms that do not - * have POSIX signals, such as Windows. - * - '-S' Specifies a service directive string. Enclose the string in quotes - * and escape any embedded quotes with a backslash. This option - * specifies service directives without the need for a configuration - * file. Can be specified multiple times. - * - * Note: Options '-f' and '-S' complement each other. Directives from files - * and from '-S' option are processed together in the following order. First, - * all files are processed in the order they are specified in @a argv - * parameter. Second, all directive strings are executed in the order the - * directives appear in @a argv parameter. - * - * @param argc The number of commandline arguments. - * @param argv The array with commandline arguments - * @param logger_key Indicates where to write the logging output, - * which is typically either a STREAM pipe or a - * socket address. - * @param ignore_static_svcs If true then static services are not loaded, - * otherwise, they are loaded. - * @param ignore_default_svc_conf_file If non-0 then the @c svc.conf - * configuration file will be ignored. - * @param ignore_debug_flag If true then the application is responsible - * for setting the @c ACE_Log_Msg::priority_mask - * appropriately. - * - * @retval -1 The configuration file is not found or cannot - * be opened (errno is set accordingly). - * @retval 0 Success. - * @retval >0 The number of errors encountered while processing - * the service configuration file(s). - */ - static int open (int argc, - ACE_TCHAR *argv[], - const ACE_TCHAR *logger_key = ACE_DEFAULT_LOGGER_KEY, - bool ignore_static_svcs = true, - bool ignore_default_svc_conf_file = false, - bool ignore_debug_flag = false); - - /// Tidy up and perform last rites when ACE_Service_Config is shut - /// down. This method calls close_svcs(). Returns 0. - static int close (void); - - /// Perform user-specified close hooks and possibly delete all of the - /// configured services in the . - static int fini_svcs (void); - - /// True if reconfiguration occurred. - static int reconfig_occurred (void); - - /// Indicate that reconfiguration occurred. - static void reconfig_occurred (int); - - /// Perform the reconfiguration process. - static void reconfigure (void); - - // = The following methods are static in order to enforce Singleton - // semantics for the Reactor, Service_Repository, Thread_Manager, - // and Acceptor/Connector Strategy factory. Other portions of the - // system may need to access them at some point or another... - - // = This is not strictly needed, anymore since the service configurator - // has been refactored to allow multiple service configuration - // instances (called gestalts). The interfaces, however were retained in for - // the sake of maintaining source-code compatibility. - - - // = Accessors and mutators for process-wide Singletons. - - /// Returns a pointer to the list of statically linked services. - /// - /// @deprecated - Same as instance(), but still useful in legacy code, - /// (notably, one that can not be easily modified) which uses the following - /// idiom for registering static services: - /// - /// ACE_Service_Config::static_svcs ()->insert (...); - static ACE_Service_Gestalt* static_svcs (void); - - /// Insert a static service descriptor for processing on open_i(). The - /// corresponding ACE_STATIC_SVC_* macros were chaged to use this method - /// instead of obtaining a ptr to a container. See the note on static_svcs(). - /// Added to prevent exposing the internal storage representation of the - /// services repository and provide a better way of debugging service - /// loading and registration problems. - static int insert (ACE_Static_Svc_Descriptor *svc); - - // = Utility methods. - /// Dynamically link the shared object file and retrieve a pointer to - /// the designated shared object in this file. - static int initialize (const ACE_Service_Type *, - const ACE_TCHAR *parameters); - - /// Initialize and activate a statically @a svc_name service. - static int initialize (const ACE_TCHAR *svc_name, - const ACE_TCHAR *parameters); - - /// Resume a @a svc_name that was previously suspended or has not yet - /// been resumed (e.g., a static service). - static int resume (const ACE_TCHAR svc_name[]); - - /** - * Suspend @a svc_name. Note that this will not unlink the service - * from the daemon if it was dynamically linked, it will mark it as - * being suspended in the Service Repository and call the - * member function on the appropriate ACE_Service_Object. A - * service can be resumed later on by calling the member - * function... - */ - static int suspend (const ACE_TCHAR svc_name[]); - - /// Totally remove @a svc_name from the daemon by removing it - /// from the ACE_Reactor, and unlinking it if necessary. - static int remove (const ACE_TCHAR svc_name[]); - -#if defined (ACE_HAS_WINCE) && defined (ACE_USES_WCHAR) - // We must provide these function to bridge the Svc_Conf parser - // with ACE. - static int initialize (const ACE_Service_Type *, ACE_ANTI_TCHAR []); - static int initialize (const char svc_name[], ACE_ANTI_TCHAR parameters[]); - static int resume (const ACE_ANTI_TCHAR svc_name[]); - static int suspend (const ACE_ANTI_TCHAR svc_name[]); - static int remove (const ACE_ANTI_TCHAR svc_name[]); -#endif /* ACE_HAS_WINCE */ - - /// Dump the state of an object. - void dump (void) const; - - /// Set the signal_handler;for internal use by ACE_Object_Manager only. - static ACE_INLINE void signal_handler (ACE_Sig_Adapter *); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - /// Process a file containing a list of service configuration - /// directives. - static int process_file (const ACE_TCHAR file[]); - - /// Process one service configuration @a directive, which is passed as - /// a string. Returns the number of errors that occurred. - static int process_directive (const ACE_TCHAR directive[]); - - /** - * Process one static service definition. Load a new static service - * into the ACE_Service_Repository. - * - * @param ssd Service descriptor, see the document of - * ACE_Static_Svc_Descriptor for more details. - * - * @param force_replace If set the new service descriptor replaces - * any previous instance in the ACE_Service_Repository. - * - * @return Returns -1 if the service cannot be 'loaded'. - */ - static int process_directive (const ACE_Static_Svc_Descriptor &ssd, - bool force_replace = false); - - /** - * Process (or re-process) service configuration requests that are - * provided in the svc.conf file(s). Returns the number of errors - * that occurred. - */ - static int process_directives (void); - - /// Handles signals to trigger reconfigurations. - static void handle_signal (int sig, siginfo_t *, ucontext_t *); - - /** - * Handle the command-line options intended for the - * ACE_Service_Config. Note that @c argv[0] is assumed to be the - * program name. - * The arguments that are valid in a call to this method are - * - '-b' Option to indicate that we should be a daemon - * - '-d' Turn on debugging mode - * - '-f' Option to read in the list of svc.conf file names - * - '-k' Option to read a wide string where in the logger output can - * be written - * - '-y' Turn on the flag for a repository of statically - * linked services - * - '-n' Need not have a repository of statically linked services - * - '-S' Option to read in the list of services on the command-line - * Please observe the difference between options '-f' that looks - * for a list of files and here a list of services. - */ - static int parse_args (int, ACE_TCHAR *argv[]); - -#if (ACE_USES_CLASSIC_SVC_CONF == 0) - static ACE_Service_Type *create_service_type (const ACE_TCHAR *n, - ACE_Service_Type_Impl *o, - ACE_DLL &dll, - int active); -#endif /* ACE_USES_CLASSIC_SVC_CONF == 0 */ - - static ACE_Service_Type_Impl * - create_service_type_impl (const ACE_TCHAR *name, - int type, - void *symbol, - u_int flags, - ACE_Service_Object_Exterminator gobbler); - - /// @deprecated - /// Process service configuration requests that were provided on the - /// command-line. Returns the number of errors that occurred. - static int process_commandline_directives (void); - - /// Become a daemon. - static int start_daemon (void); - - // @deprecated - // Add the default statically-linked services to the - // ACE_Service_Repository. - static int load_static_svcs (void); - -protected: - -#if (ACE_USES_CLASSIC_SVC_CONF == 1) - /// @deprecated - /// This is the implementation function that process_directives() - /// and process_directive() both call. Returns the number of errors - /// that occurred. - static int process_directives_i (ACE_Svc_Conf_Param *param); -#endif /* ACE_USES_CLASSIC_SVC_CONF == 1 */ - - - // = Process-wide state. - -private: - - /// Have we called ACE_Service_Config::open() yet? - bool is_opened_; - -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - /// Synchronization variable for open, etc. - mutable ACE_SYNCH_MUTEX lock_; -#endif /* ACE_MT_SAFE */ - - /// True if reconfiguration occurred. - static sig_atomic_t reconfig_occurred_; - - // = Set by command-line options. - /// Shall we become a daemon process? - static bool be_a_daemon_; - - /// Pathname of file to write process id. - static ACE_TCHAR *pid_file_name_; - - /// Number of the signal used to trigger reconfiguration. - static int signum_; - - /// Handles the reconfiguration signals. - static ACE_Sig_Adapter *signal_handler_; - - /// Pointer to the Singleton (ACE_Cleanup) Gestalt instance. - /// There is thread-specific global instance pointer, which is used to - /// temporarily change which Gestalt instance is used for static service - /// registrations. - /// - /// A specific use case is a thread, which loads a _dynamic_ service from - /// a DLL. If the said DLL also contains additional _static_ services, - /// those *must* be registered with the same configuration repository as - /// the dynamic service. Otherwise, the DLL's static services would be - /// registered with the global Gestalt and may outlive the DLL that - /// contains their code and perhaps the memory in which they are in. - /// This is a problem because if the DLL gets unloaded (as it will, if - /// it was loaded in an instance of Gestalt), the DLL's memory will be - /// deallocated, but the global service repository will still "think" - /// it must finalize the (DLL's) static services - with disastrous - /// consequences, occurring in the post-main code (at_exit()). - - /// This class needs the intimate access to be able to swap the - /// current TSS pointer for the global Gestalt. - friend class ACE_Service_Config_Guard; - - /// The helper needs intimate access (when building with no threads) - friend class ACE_Threading_Helper ; - friend class ACE_Threading_Helper ; -}; - -/** - * @class ACE_Service_Config_Guard - * - * @brief A guard class, designed to be instantiated on the stack. - * - * Instantiating it with a specific configuration ensures any references to - * ACE_Service_Config::instance(), even when occurring in static constructors, - * will allways access the designated configuration instance. - * This comes very handy when a dynamic service also registers any static - * services of its own and their static factories. - */ -class ACE_Export ACE_Service_Config_Guard -{ -public: - ACE_Service_Config_Guard (ACE_Service_Gestalt* psg); - ~ACE_Service_Config_Guard (void); - -private: - // Private AND not implemented to disable copying - ACE_Service_Config_Guard(const ACE_Service_Config_Guard&); - ACE_Service_Config_Guard& operator= (const ACE_Service_Config_Guard&); - -private: - ACE_Intrusive_Auto_Ptr saved_; -}; - - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Service_Config.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* ACE_SERVICE_CONFIG_H */ diff --git a/deps/acelite/ace/Service_Config.inl b/deps/acelite/ace/Service_Config.inl deleted file mode 100644 index 5cffe4344..000000000 --- a/deps/acelite/ace/Service_Config.inl +++ /dev/null @@ -1,205 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// This is the primary entry point into the ACE_Service_Config (the -// constructor just handles simple initializations). -ACE_INLINE int -ACE_Service_Config::open (const ACE_TCHAR program_name[], - const ACE_TCHAR *logger_key, - bool ignore_static_svcs, - bool ignore_default_svc_conf, - bool ignore_debug_flag) -{ - ACE_TRACE ("ACE_Service_Config::open"); - if (singleton()->open_i (program_name, - logger_key, - ignore_static_svcs, - ignore_default_svc_conf, - ignore_debug_flag) == -1) - return -1; - - return current()->open (program_name, - logger_key, - ignore_static_svcs, - ignore_default_svc_conf, - ignore_debug_flag); -} - - -ACE_INLINE int -ACE_Service_Config::open (int argc, - ACE_TCHAR *argv[], - const ACE_TCHAR *logger_key, - bool ignore_static_svcs, - bool ignore_default_svc_conf, - bool ignore_debug_flag) -{ - ACE_TRACE ("ACE_Service_Config::open"); - - if (singleton()->parse_args_i(argc, argv) == -1) - return -1; - - if (singleton()->open_i (argv[0], - logger_key, - ignore_static_svcs, - ignore_default_svc_conf, - ignore_debug_flag) == -1) - return -1; - - return current()->open (argc, - argv, - logger_key, - ignore_static_svcs, - ignore_default_svc_conf, - ignore_debug_flag); -} - -// Handle the command-line options intended for the -// ACE_Service_Config. -ACE_INLINE int -ACE_Service_Config::parse_args (int argc, ACE_TCHAR *argv[]) -{ - return ACE_Service_Config::current ()->parse_args (argc, argv); -} - -/// Return the global configuration instance. Allways returns the same -/// instance -ACE_INLINE ACE_Service_Gestalt * -ACE_Service_Config::global (void) -{ - return ACE_Service_Config::singleton()->instance_.get (); -} - -/// Return the configuration instance, considered "global" in the -/// current thread. This may be the same as instance(), but on some -/// occasions, it may be a different one. For example, -/// ACE_Service_Config_Guard provides a way of temporarily replacing -/// the "current" configuration instance in the context of a thread. -ACE_INLINE ACE_Service_Gestalt * -ACE_Service_Config::instance (void) -{ - return ACE_Service_Config::current (); -} - -// This method has changed to return the gestalt instead of the -// container, underlying the service repository and defined -// ACE_Service_Gestalt::insert (ACE_Static_Svc_Descriptor*). This way -// the existing source code can keep using -// ACE_Service_Config::static_svcs(), however now it is not necessary -// to expose the repository storage *and* it is much easier to debug -// service registration problems. - -ACE_INLINE ACE_Service_Gestalt* -ACE_Service_Config::static_svcs (void) -{ - return ACE_Service_Config::current (); -} - -/// Compare two service descriptors for equality. -ACE_INLINE bool -ACE_Static_Svc_Descriptor::operator== (ACE_Static_Svc_Descriptor &d) const -{ - return ACE_OS::strcmp (name_, d.name_) == 0; -} - -/// Compare two service descriptors for inequality. -ACE_INLINE bool -ACE_Static_Svc_Descriptor::operator!= (ACE_Static_Svc_Descriptor &d) const -{ - return !(*this == d); -} - -ACE_INLINE void -ACE_Service_Config::signal_handler (ACE_Sig_Adapter *signal_handler) -{ - signal_handler_ = signal_handler; -} - -/// Initialize and activate a statically linked service. -ACE_INLINE int -ACE_Service_Config::initialize (const ACE_TCHAR *svc_name, - const ACE_TCHAR *parameters) -{ - ACE_TRACE ("ACE_Service_Config::initialize"); - return ACE_Service_Config::current ()->initialize (svc_name, - parameters); -} - -/// Dynamically link the shared object file and retrieve a pointer to -/// the designated shared object in this file. -ACE_INLINE int -ACE_Service_Config::initialize (const ACE_Service_Type *sr, - const ACE_TCHAR *parameters) -{ - ACE_TRACE ("ACE_Service_Config::initialize"); - return ACE_Service_Config::current ()->initialize (sr, parameters); -} - -/// Process a file containing a list of service configuration -/// directives. -ACE_INLINE int ACE_Service_Config::process_file (const ACE_TCHAR file[]) -{ - return ACE_Service_Config::current ()->process_file (file); -} - -/// -ACE_INLINE int -ACE_Service_Config::process_directive (const ACE_TCHAR directive[]) -{ - return ACE_Service_Config::current ()->process_directive (directive); -} - -/// Process service configuration requests as indicated in the queue of -/// svc.conf files. -ACE_INLINE int -ACE_Service_Config::process_directives (void) -{ - return ACE_Service_Config::current ()->process_directives (false); -} - -ACE_INLINE int -ACE_Service_Config::process_directive (const ACE_Static_Svc_Descriptor &ssd, - bool force_replace) -{ - return ACE_Service_Config::current ()->process_directive (ssd, force_replace); -} - - -#if defined (ACE_HAS_WINCE) && defined (ACE_USES_WCHAR) -// We must provide these function to bridge Svc_Conf parser with ACE. - -ACE_INLINE int -ACE_Service_Config::initialize (const ACE_Service_Type *sp, ACE_ANTI_TCHAR parameters[]) -{ - return ACE_Service_Config::initialize (sp, ACE_TEXT_ANTI_TO_TCHAR (parameters)); -} - -ACE_INLINE int -ACE_Service_Config::initialize (const ACE_ANTI_TCHAR svc_name[], ACE_ANTI_TCHAR parameters[]) -{ - return ACE_Service_Config::initialize (ACE_TEXT_ANTI_TO_TCHAR (svc_name), - ACE_TEXT_ANTI_TO_TCHAR (parameters)); -} - -ACE_INLINE int -ACE_Service_Config::resume (const ACE_ANTI_TCHAR svc_name[]) -{ - return ACE_Service_Config::resume (ACE_TEXT_ANTI_TO_TCHAR (svc_name)); -} - -ACE_INLINE int -ACE_Service_Config::suspend (const ACE_ANTI_TCHAR svc_name[]) -{ - return ACE_Service_Config::suspend (ACE_TEXT_ANTI_TO_TCHAR (svc_name)); -} - -ACE_INLINE int -ACE_Service_Config::remove (const ACE_ANTI_TCHAR svc_name[]) -{ - return ACE_Service_Config::remove (ACE_TEXT_ANTI_TO_TCHAR (svc_name)); -} -#endif /* ACE_HAS_WINCE && !ACE_USES_WCHAR */ - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Service_Gestalt.cpp b/deps/acelite/ace/Service_Gestalt.cpp deleted file mode 100644 index 6bc653bf2..000000000 --- a/deps/acelite/ace/Service_Gestalt.cpp +++ /dev/null @@ -1,1335 +0,0 @@ -#include "ace/Svc_Conf.h" -#include "ace/Get_Opt.h" -#include "ace/ARGV.h" -#include "ace/Malloc.h" -#include "ace/Service_Manager.h" -#include "ace/Service_Types.h" -#include "ace/Containers.h" -#include "ace/Auto_Ptr.h" -#include "ace/Reactor.h" -#include "ace/Thread_Manager.h" -#include "ace/DLL.h" -#include "ace/XML_Svc_Conf.h" -#include "ace/SString.h" - -#ifndef ACE_LACKS_UNIX_SIGNALS -# include "ace/Signal.h" -#endif /* !ACE_LACKS_UNIX_SIGNALS */ - -#include "ace/OS_NS_stdio.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_NS_time.h" -#include "ace/OS_NS_unistd.h" -#include "ace/OS_NS_sys_stat.h" - -#include "ace/TSS_T.h" -#include "ace/Service_Gestalt.h" - -#include "ace/Svc_Conf_Param.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Service_Type_Dynamic_Guard::ACE_Service_Type_Dynamic_Guard - (ACE_Service_Repository &r, const ACE_TCHAR *name) - : repo_ (r) - // Relocation starts where the next service will be inserted (if any) - , repo_begin_ (r.current_size ()) - , name_ (name) -# if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - // On this thread (for the duration of the initialize() method), - // we're about to do two things that require locking: (1) fiddle - // with the repository and (2) load a DLL and hence lock the - // DLL_Manager. - // - // Now if we don't lock the repo here, it is possible that two - // threads may deadlock on initialization because they can acquire - // locks (1) and (2) in different order, for instance: - // - // T1: loads a DLL (2) and registers a service (1); - // - // T2: may be relocating a service (1), which could lead to a - // (re)opening or uping the ref count on a DLL (2); - // - // To prevent this, we lock the repo here, using the repo_monitor_ - // member guard. - , repo_monitor_ (r.lock_) -#endif -{ - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) STDG::, repo=%@") - ACE_TEXT(", name=%s - beginning at [%d]\n"), - &this->repo_, - this->name_, - this->repo_begin_)); - - ACE_ASSERT (this->name_ != 0); // No name? -} - - -/// Destructor -ACE_Service_Type_Dynamic_Guard::~ACE_Service_Type_Dynamic_Guard (void) -{ - const ACE_Service_Type *tmp = 0; - - // Lookup without ignoring suspended services. Making sure - // not to ignore any inactive services, since those may be forward - // declarations - size_t slot = 0; - int const ret = this->repo_.find_i (this->name_, slot, &tmp, false); - - // We inserted it (as inactive), so we expect to find it, right? - if ((ret < 0 && ret != -2) || tmp == 0) - { - if (ACE::debug ()) - ACELIB_ERROR ((LM_WARNING, - ACE_TEXT ("ACE (%P|%t) STDG:: - Failed (%d) to find %s -> %@\n"), - ret, this->name_, tmp)); - return; - } - - if (tmp->type () != 0) - { - // Something has registered a proper (non-forward-decl) service with - // the same name as our dummy. - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) STDG::, repo=%@ [%d], ") - ACE_TEXT ("name=%s - updating dependents [%d - %d)\n"), - &this->repo_, - slot, - this->name_, - this->repo_begin_, - this->repo_.current_size ())); - - // Relocate any services inserted since we were created. - // Any (static, i.e. DLL = 0) services registered in - // the context of this guard aren't really static because - // their code belongs in the DLL's code segment - this->repo_.relocate_i (this->repo_begin_, this->repo_.current_size (), tmp->dll()); - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) STDG::, repo=%@ [%d], ") - ACE_TEXT ("name=%s - loaded (type=%@, impl=%@, object=%@, active=%d)\n"), - &this->repo_, - slot, - this->name_, - tmp, - tmp->type (), - tmp->type ()->object (), - tmp->active ())); - } -} - - - -// ---------------------------------------- - -ACE_Service_Gestalt::Processed_Static_Svc:: -Processed_Static_Svc (const ACE_Static_Svc_Descriptor *assd) - :name_(0), - assd_(assd) -{ -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_ALLOCATOR_NORETURN (name_, static_cast(ACE_Allocator::instance()->malloc (sizeof(ACE_TCHAR) * (ACE_OS::strlen(assd->name_)+1)))); -#else - ACE_NEW_NORETURN (name_, ACE_TCHAR[ACE_OS::strlen(assd->name_)+1]); -#endif /* ACE_HAS_ALLOC_HOOKS */ - ACE_OS::strcpy(name_,assd->name_); -} - -ACE_Service_Gestalt::Processed_Static_Svc::~Processed_Static_Svc (void) -{ -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(name_); -#else - delete [] name_; -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Service_Gestalt::Processed_Static_Svc) - -void -ACE_Service_Gestalt::intrusive_add_ref (ACE_Service_Gestalt* g) -{ - if (g != 0) - { - ++g->refcnt_; - ACE_ASSERT (g->refcnt_ > 0); - } -} - -void -ACE_Service_Gestalt::intrusive_remove_ref (ACE_Service_Gestalt* g) -{ - if (g != 0) - { - long tmp = --g->refcnt_; - if (tmp <= 0) delete g; - ACE_ASSERT (tmp >= 0); - } -} - - -ACE_Service_Gestalt::~ACE_Service_Gestalt (void) -{ - - if (this->svc_repo_is_owned_) - delete this->repo_; - - this->repo_ =0; - - delete this->static_svcs_; - this->static_svcs_ = 0; - - // Delete the dynamically allocated static_svcs instance. -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SG::~SG - this=%@, pss = %@\n"), - this, this->processed_static_svcs_)); -#endif - - if (this->processed_static_svcs_ && - !this->processed_static_svcs_->is_empty()) - { - Processed_Static_Svc **pss = 0; - for (ACE_PROCESSED_STATIC_SVCS_ITERATOR iter (*this->processed_static_svcs_); - iter.next (pss) != 0; - iter.advance ()) - { - delete *pss; - } - } - - delete this->processed_static_svcs_; - this->processed_static_svcs_ = 0; - - delete this->svc_conf_file_queue_; - this->svc_conf_file_queue_ = 0; - - delete this->svc_queue_; - this->svc_queue_ = 0; -} - -ACE_Service_Gestalt::ACE_Service_Gestalt (size_t size, - bool svc_repo_is_owned, - bool no_static_svcs) - : svc_repo_is_owned_ (svc_repo_is_owned) - , svc_repo_size_ (size) - , is_opened_ (0) - , logger_key_ (ACE_DEFAULT_LOGGER_KEY) - , no_static_svcs_ (no_static_svcs) - , svc_queue_ (0) - , svc_conf_file_queue_ (0) - , repo_ (0) - , static_svcs_ (0) - , processed_static_svcs_ (0) - , refcnt_ (0) -{ - (void)this->init_i (); - -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SG::ctor - this = %@, pss = %@\n"), - this, this->processed_static_svcs_)); -#endif -} - -/// Performs the common initialization tasks for a new or previously -/// closed instance. Must not be virtual, as it is also called from -/// the constructor. -int -ACE_Service_Gestalt::init_i (void) -{ - // Only initialize the repo_ if (a) we are being constructed, or; - // (b) we're being open()-ed, perhaps after previously having been - // close()-ed. In both cases: repo_ == 0 and we need a repository. - if (this->repo_ == 0) - { - if (this->svc_repo_is_owned_) - { - ACE_NEW_RETURN (this->repo_, - ACE_Service_Repository (this->svc_repo_size_), - -1); - } - else - { - this->repo_ = - ACE_Service_Repository::instance (this->svc_repo_size_); - } - } - - if (init_svc_conf_file_queue () == -1) - return -1; - - return 0; -} - - -/// Add the default statically-linked services to the Service -/// Repository. -int -ACE_Service_Gestalt::load_static_svcs (void) -{ - ACE_TRACE ("ACE_Service_Gestalt::load_static_svcs"); - - if (this->static_svcs_ == 0) - return 0; // Nothing to do - - ACE_Static_Svc_Descriptor **ssdp = 0; - for (ACE_STATIC_SVCS_ITERATOR iter (*this->static_svcs_); - iter.next (ssdp) != 0; - iter.advance ()) - { - ACE_Static_Svc_Descriptor *ssd = *ssdp; - - if (this->process_directive (*ssd, 1) == -1) - return -1; - } - return 0; - -} /* load_static_svcs () */ - - - -/// Find a static service descriptor by name -int -ACE_Service_Gestalt::find_static_svc_descriptor (const ACE_TCHAR* name, - ACE_Static_Svc_Descriptor **ssd) const -{ - ACE_TRACE ("ACE_Service_Gestalt::find_static_svc_descriptor"); - - if (this->static_svcs_ == 0) - return -1; - - ACE_Static_Svc_Descriptor **ssdp = 0; - for (ACE_STATIC_SVCS_ITERATOR iter ( *this->static_svcs_); - iter.next (ssdp) != 0; - iter.advance ()) - { - if (ACE_OS::strcmp ((*ssdp)->name_, name) == 0) - { - if (ssd != 0) - *ssd = *ssdp; - - return 0; - } - } - - return -1; -} - -/// @brief -const ACE_Static_Svc_Descriptor* -ACE_Service_Gestalt::find_processed_static_svc (const ACE_TCHAR* name) -{ - if (this->processed_static_svcs_ == 0 || name == 0) - return 0; - - Processed_Static_Svc **pss = 0; - for (ACE_PROCESSED_STATIC_SVCS_ITERATOR iter (*this->processed_static_svcs_); - iter.next (pss) != 0; - iter.advance ()) - { - if (ACE_OS::strcmp ((*pss)->name_, name) == 0) - return (*pss)->assd_; - } - return 0; -} - - - -/// @brief Captures a list of the direcives processed (explicitely) for this -/// Gestalt so that services can be replicated in other repositories -/// upon their first initialization. -/// -/// This is part of the mechanism ensuring distinct local instances -/// for static service objects, loaded in another repository. -void -ACE_Service_Gestalt::add_processed_static_svc - (const ACE_Static_Svc_Descriptor *assd) -{ - - /// When process_directive(Static_Svc_Descriptor&) is called, it - /// associates a service object with the Gestalt and makes the - /// resource (a Service Object) local to the repository. This is but - /// the first step in using such SO. The next is the - /// "initialization" step. It is typically done through a "static" - /// service configuration directive. - /// - /// In contrast a "dynamic" directive, when processed through the - /// overloaded process_directives(string) both creates the SO - /// locally and initializes it, where the statics directive must - /// first locate the SO and then calls the init() method. This means - /// that durig the "static" initialization there's no specific - /// information about the hosting repository and the gestalt must - /// employ some lookup strategy to find it elsewhere. - - if (this->processed_static_svcs_ == 0) - ACE_NEW (this->processed_static_svcs_, - ACE_PROCESSED_STATIC_SVCS); - - Processed_Static_Svc **pss = 0; - for (ACE_PROCESSED_STATIC_SVCS_ITERATOR iter (*this->processed_static_svcs_); - iter.next (pss) != 0; - iter.advance ()) - { - if (ACE_OS::strcmp ((*pss)->name_, assd->name_) == 0) - { - (*pss)->assd_ = assd; - return; - } - } - Processed_Static_Svc *tmp = 0; - ACE_NEW (tmp,Processed_Static_Svc(assd)); - this->processed_static_svcs_->insert(tmp); - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SG::add_processed_static_svc, ") - ACE_TEXT ("repo=%@ - %s\n"), - this->repo_, - assd->name_)); -} - - -/// Queues a static service object descriptor which, during open() -/// will be given to process_directive() to create the Service -/// Object. Normally, only called from static initializers, prior to -/// calling open() but loading a service from a DLL can cause it too. - -int -ACE_Service_Gestalt::insert (ACE_Static_Svc_Descriptor *stsd) -{ - if (this->static_svcs_ == 0) - ACE_NEW_RETURN (this->static_svcs_, - ACE_STATIC_SVCS, - -1); - - return this->static_svcs_->insert (stsd); -} - - -ACE_ALLOC_HOOK_DEFINE (ACE_Service_Gestalt) - - -void -ACE_Service_Gestalt::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Service_Gestalt::dump"); -#endif /* ACE_HAS_DUMP */ -} - -int -ACE_Service_Gestalt::initialize (const ACE_TCHAR *svc_name, - const ACE_TCHAR *parameters) -{ - ACE_TRACE ("ACE_Service_Gestalt_Base::initialize (repo)"); - ACE_ARGV args (parameters); - -#ifndef ACE_NLOGGING - if (ACE::debug ()) - { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SG::initialize - () repo=%@, ") - ACE_TEXT ("looking up static ") - ACE_TEXT ("service \'%s\' to initialize\n"), - this->repo_, - svc_name)); - } -#endif - - const ACE_Service_Type *srp = 0; - for (int i = 0; this->find (svc_name, &srp) == -1 && i < 2; i++) - // if (this->repo_->find (svc_name, &srp) == -1) - { - const ACE_Static_Svc_Descriptor *assd = - ACE_Service_Config::global()->find_processed_static_svc(svc_name); - if (assd != 0) - { - this->process_directive_i(*assd, 0); - } - else - { - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) ERROR: SG::initialize - service \'%s\'") - ACE_TEXT (" was not located.\n"), - svc_name), - -1); - } - } - if (srp == 0) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) ERROR: SG::initialize - service \'%s\'") - ACE_TEXT (" was not located.\n"), - svc_name), - -1); - - /// If initialization fails ... - if (srp->type ()->init (args.argc (), - args.argv ()) == -1) - { - // ... report and remove this entry. - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) ERROR: SG::initialize - static init of \'%s\'") - ACE_TEXT (" failed (%p)\n"), - svc_name, ACE_TEXT ("error"))); - this->repo_->remove (svc_name); - return -1; - } - - // If everything is ok, activate it - const_cast(srp)->active (1); - return 0; -} - - -#if (ACE_USES_CLASSIC_SVC_CONF == 1) -int -ACE_Service_Gestalt::initialize (const ACE_Service_Type_Factory *stf, - const ACE_TCHAR *parameters) -{ - ACE_TRACE ("ACE_Service_Gestalt::initialize"); - -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SG::initialize - repo=%@, name=%s") - ACE_TEXT (" - looking up in the repo\n"), - this->repo_, - stf->name ())); -#endif - - ACE_Service_Type *srp = 0; - int const retv = this->repo_->find (stf->name (), - (const ACE_Service_Type **) &srp); - - // If there is an active service already, remove it first - // before it can be re-installed. - if (retv >= 0) - { -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_WARNING, - ACE_TEXT ("ACE (%P|%t) SG::initialize - repo=%@,") - ACE_TEXT (" name=%s - removing a pre-existing namesake.\n"), - this->repo_, - stf->name ())); -#endif - this->repo_->remove (stf->name ()); - } - - // If there is an inactive service by that name it may have been - // either inactivated, or just a forward declaration for a service, - // that is in the process of being initialized. If it is the latter, - // then we have detected an attempt to initialize the same dynamic - // service while still processing previous attempt. This can lock up - // the process, because the ACE_DLL_Manager::open () is not - // re-entrant - it uses a Singleton lock to serialize concurent - // invocations. This use case must be handled here, because if the - // DLL_Manager was re-entrant we would have entered an infinite - // recursion here. - if (retv == -2 && srp->type () == 0) - ACELIB_ERROR_RETURN ((LM_WARNING, - ACE_TEXT ("ACE (%P|%t) SG::initialize - repo=%@,") - ACE_TEXT (" name=%s - forward-declared; ") - ACE_TEXT (" recursive initialization requests are") - ACE_TEXT (" ignored.\n"), - this->repo_, - stf->name ()), - -1); - - // Reserve a spot for the dynamic service by inserting an incomplete - // service declaration, i.e. one that can not produce a service - // object if asked (a forward declaration). This declaration - // ensures maintaining the proper partial ordering of the services - // with respect to their finalization. For example, dependent static - // services must be registered *after* the dynamic service that - // loads them, so that their finalization is complete *before* - // finalizing the dynamic service. - ACE_Service_Type_Dynamic_Guard dummy (*this->repo_, - stf->name ()); - - // make_service_type() is doing the dynamic loading and also runs - // any static initializers - ACE_Auto_Ptr tmp (stf->make_service_type (this)); - - if (tmp.get () != 0 && - this->initialize_i (tmp.get (), parameters) == 0) - { - // All good. Tthe ACE_Service_Type instance is now owned by the - // repository and we should make sure it is not destroyed upon - // exit from this method. - tmp.release (); - return 0; - } - - return -1; -} -#endif /* (ACE_USES_CLASSIC_SVC_CONF == 1) */ - - -/// Dynamically link the shared object file and retrieve a pointer to -/// the designated shared object in this file. -/// @note This is obsolete (and error-prone) in the presense of dynamic -/// services with their own static services. This method will allow those -/// static services to register *before* the dynamic service that owns them. -/// Upon finalization of the static services the process may crash, because -/// the dynamic service's DLL may have been already released, together with -/// the memory in which the static services reside. -/// It may not crash, for instance, when the first static service to register -/// is the same as the dynamic service being loaded. You should be so lucky! .. -int -ACE_Service_Gestalt::initialize (const ACE_Service_Type *sr, - const ACE_TCHAR *parameters) -{ - ACE_TRACE ("ACE_Service_Gestalt::initialize"); - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SG::initialize - repo=%@, name=%s") - ACE_TEXT (" - looking up in the repo\n"), - this->repo_, - sr->name ())); - - ACE_Service_Type *srp = 0; - if (this->repo_->find (sr->name (), - (const ACE_Service_Type **) &srp) >= 0) - { -#ifndef ACE_NLOGGING - ACELIB_DEBUG ((LM_WARNING, - ACE_TEXT ("ACE (%P|%t) SG::initialize - repo=%@, name=%s") - ACE_TEXT (" - removing a pre-existing namesake.\n"), - this->repo_, - sr->name ())); -#endif - this->repo_->remove (sr->name ()); - } - - return this->initialize_i (sr, parameters); - -} - -/// Dynamically link the shared object file and retrieve a pointer to -/// the designated shared object in this file. -int -ACE_Service_Gestalt::initialize_i (const ACE_Service_Type *sr, - const ACE_TCHAR *parameters) -{ - ACE_TRACE ("ACE_Service_Gestalt::initialize_i"); - ACE_ARGV args (parameters); - if (sr->type ()->init (args.argc (), - args.argv ()) == -1) - { - // We just get ps to avoid having remove() delete it. - ACE_Service_Type *ps = 0; - this->repo_->remove (sr->name (), &ps); - -#ifndef ACE_NLOGGING - // Not using LM_ERROR here to avoid confusing the test harness - if (ACE::debug ()) - ACELIB_ERROR_RETURN ((LM_WARNING, - ACE_TEXT ("ACE (%P|%t) SG::initialize_i -") - ACE_TEXT (" repo=%@, name=%s - remove failed: %m\n"), - this->repo_, - sr->name ()), - -1); -#endif - return -1; - } - - if (this->repo_->insert (sr) == -1) - { -#ifndef ACE_NLOGGING - // Not using LM_ERROR here to avoid confusing the test harness - if (ACE::debug ()) - ACELIB_ERROR_RETURN ((LM_WARNING, - ACE_TEXT ("ACE (%P|%t) SG::initialize_i -") - ACE_TEXT (" repo=%@, name=%s - insert failed: %m\n"), - this->repo_, - sr->name ()), - -1); -#endif - return -1; - } - - return 0; -} - -// Totally remove from the daemon by removing it from the -// ACE_Reactor, and unlinking it if necessary. - -int -ACE_Service_Gestalt::remove (const ACE_TCHAR svc_name[]) -{ - ACE_TRACE ("ACE_Service_Gestalt::remove"); - if (this->repo_ == 0) - return -1; - - return this->repo_->remove (svc_name); -} - -/// Suspend @a svc_name. Note that this will not unlink the service -/// from the daemon if it was dynamically linked, it will mark it as -/// being suspended in the Service Repository and call the -/// member function on the appropriate . A service -/// can be resumed later on by calling the method... -int -ACE_Service_Gestalt::suspend (const ACE_TCHAR svc_name[]) -{ - ACE_TRACE ("ACE_Service_Gestalt::suspend"); - if (this->repo_ == 0) - return -1; - - return this->repo_->suspend (svc_name); -} - -// Resume a SVC_NAME that was previously suspended or has not yet -// been resumed (e.g., a static service). - -int -ACE_Service_Gestalt::resume (const ACE_TCHAR svc_name[]) -{ - ACE_TRACE ("ACE_Service_Gestalt::resume"); - if (this->repo_ == 0) - return -1; - - return this->repo_->resume (svc_name); -} - - -int -ACE_Service_Gestalt::process_directive (const ACE_Static_Svc_Descriptor &ssd, - bool force_replace) -{ - int const result = process_directive_i (ssd, force_replace); - if (result == 0) - { - this->add_processed_static_svc(&ssd); - } - return result; -} - -int -ACE_Service_Gestalt::process_directive_i (const ACE_Static_Svc_Descriptor &ssd, - bool force_replace) -{ - if (this->repo_ == 0) - return -1; - - if (!force_replace) - { - if (this->repo_->find (ssd.name_, 0, 0) >= 0) - { - // The service is already there, just return - return 0; - } - } - - - ACE_Service_Object_Exterminator gobbler; - void *sym = (ssd.alloc_)(&gobbler); - - ACE_Service_Type_Impl *stp = - ACE_Service_Config::create_service_type_impl (ssd.name_, - ssd.type_, - sym, - ssd.flags_, - gobbler); - if (stp == 0) - return 0; - - ACE_Service_Type *service_type = 0; - - // This is just a temporary to force the compiler to use the right - // constructor in ACE_Service_Type. Note that, in cases where we are - // called from a static initializer which is part of a DLL, there is - // not enough information about the actuall DLL in this context. - ACE_DLL tmp_dll; - - ACE_NEW_RETURN (service_type, - ACE_Service_Type (ssd.name_, - stp, - tmp_dll, - ssd.active_), - -1); - -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SG::process_directive_i, ") - ACE_TEXT ("repo=%@ - %s, dll=%s, force=%d\n"), - this->repo_, - ssd.name_, - (tmp_dll.dll_name_ == 0) ? ACE_TEXT ("") : tmp_dll.dll_name_, - force_replace)); -#endif - - return this->repo_->insert (service_type); -} - -#if (ACE_USES_CLASSIC_SVC_CONF == 1) - -int -ACE_Service_Gestalt::process_directives_i (ACE_Svc_Conf_Param *param) -{ -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SG::process_directives_i, ") - ACE_TEXT ("repo=%@ - %s\n"), - this->repo_, - (param->type == ACE_Svc_Conf_Param::SVC_CONF_FILE) - ? ACE_TEXT ("") - : param->source.directive)); -#endif - - // Were we called in the context of the current instance? - ACE_ASSERT (this == param->config); - - // Temporarily (for the duration of this call) make sure that *any* - // static service registrations will happen with this instance. Such - // registrations are possible as a side-effect of dynamically - // loading a DLL, which has other static services registered. Thus - // this instance will own both the DLL and those static services, - // which implies that their finalization will be performed in the - // correct order, i.e. prior to finalizing the DLL - ACE_Service_Config_Guard guard (this); - - ::ace_yyparse (param); - - // This is a hack, better errors should be provided... - if (param->yyerrno > 0) - { - // Always set the last error if ace_yyparse() fails. - // Other code may use errno to determine the type - // of problem that occurred from processing directives. - ACE_OS::last_error (EINVAL); - return param->yyerrno; - } - else - return 0; -} - -#else - -ACE_XML_Svc_Conf * -ACE_Service_Gestalt::get_xml_svc_conf (ACE_DLL &xmldll) -{ - if (xmldll.open (ACE_TEXT ("ACEXML_XML_Svc_Conf_Parser")) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) Failure to open ACEXML_XML_Svc_Conf_Parser: %p\n"), - ACE_TEXT("ACE_Service_Config::get_xml_svc_conf")), - 0); - - void * foo = - xmldll.symbol (ACE_TEXT ("_ACEXML_create_XML_Svc_Conf_Object")); - -#if defined (ACE_OPENVMS) && (!defined (__INITIAL_POINTER_SIZE) || (__INITIAL_POINTER_SIZE < 64)) - int const temp_p = reinterpret_cast (foo); -#else - intptr_t const temp_p = reinterpret_cast (foo); -#endif - - ACE_XML_Svc_Conf::Factory factory = reinterpret_cast (temp_p); - - if (factory == 0) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) Unable to resolve factory: %p\n"), - xmldll.error ()), - 0); - - return factory (); -} -#endif /* ACE_USES_CLASSIC_SVC_CONF == 1 */ - -int -ACE_Service_Gestalt::process_file (const ACE_TCHAR file[]) -{ - ACE_TRACE ("ACE_Service_Gestalt::process_file"); - - // To avoid recursive processing of the same file and the same repository - // we maintain an implicit stack of dummy "services" named after the file - // being processed. Anytime we have to open a new file, we then can check - // to see if it is not already being processed by searching for a dummy - // service with a matching name. - if (this->repo_->find (file, 0, 0) >=0) - { - ACELIB_DEBUG ((LM_WARNING, - ACE_TEXT ("ACE (%P|%t) Configuration file %s is currently") - ACE_TEXT (" being processed. Ignoring recursive process_file().\n"), - file)); - return 0; - } - - // Register a dummy service as a forward decl, using the file name as name. - // The entry will be automaticaly removed once the thread exits this block. - ACE_Service_Type_Dynamic_Guard recursion_guard (*this->repo_, - file); - - /* - * @TODO: Test with ACE_USES_CLASSIC_SVC_CONF turned off! - */ -#if (ACE_USES_CLASSIC_SVC_CONF == 1) - int result = 0; - - FILE *fp = ACE_OS::fopen (file, - ACE_TEXT ("r")); - - if (fp == 0) - { - // Invalid svc.conf file. We'll report it here and break out of - // the method. - if (ACE::debug ()) - ACELIB_DEBUG ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t): %p\n"), - file)); - - // Use stat to find out if the file exists. I didn't use access() - // because stat is better supported on most non-unix platforms. - ACE_stat exists; - if (ACE_OS::stat (file, &exists) == 0) - // If it exists, but we couldn't open it for reading then we - // must not have permission to read it. - errno = EPERM; - else - errno = ENOENT; - result = -1; - } - else - { - ACE_Svc_Conf_Param f (this, fp); - - // Keep track of the number of errors. - result = this->process_directives_i (&f); - - (void) ACE_OS::fclose (fp); - } - return result; -#else - ACE_DLL dll; - - auto_ptr xml_svc_conf (this->get_xml_svc_conf (dll)); - - if (xml_svc_conf.get () == 0) - return -1; - - return xml_svc_conf->parse_file (file); -#endif /* ACE_USES_CLASSIC_SVC_CONF == 1 */ -} - -int -ACE_Service_Gestalt::process_directive (const ACE_TCHAR directive[]) -{ - ACE_TRACE ("ACE_Service_Gestalt::process_directive"); - -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SG::process_directive, repo=%@ - %s\n"), - this->repo_, - directive)); -#endif - -#if (ACE_USES_CLASSIC_SVC_CONF == 1) - ACE_UNUSED_ARG (directive); - - ACE_Svc_Conf_Param d (this, directive); - - return this->process_directives_i (&d); -#else - ACE_DLL dll; - - auto_ptr - xml_svc_conf (this->get_xml_svc_conf (dll)); - - if (xml_svc_conf.get () == 0) - return -1; - - // Temporarily (for the duration of this call) make sure that *any* static - // service registrations will happen with this instance. Such registrations - // are possible as a side-effect of dynamically loading a DLL, which has - // other static services registered. Thus this instance will own both the - // DLL and those static services, which implies that their finalization - // will be performed in the correct order, i.e. prior to finalizing the DLL - ACE_Service_Config_Guard guard (this); - - return xml_svc_conf->parse_string (directive); -#endif /* ACE_USES_CLASSIC_SVC_CONF == 1 */ - -} /* process_directive () */ - - -int -ACE_Service_Gestalt::init_svc_conf_file_queue (void) -{ - if (this->svc_conf_file_queue_ == 0) - { - ACE_SVC_QUEUE *tmp = 0; - ACE_NEW_RETURN (tmp, - ACE_SVC_QUEUE, - -1); - this->svc_conf_file_queue_ = tmp; - } - -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SG::init_svc_conf_file_queue ") - ACE_TEXT ("- this=%@, repo=%@\n"), - this, this->repo_)); -#endif - - return 0; - -} /* init_svc_conf_file_queue () */ - - -int -ACE_Service_Gestalt::open_i (const ACE_TCHAR program_name[], - const ACE_TCHAR* logger_key, - bool ignore_static_svcs, - bool ignore_default_svc_conf_file, - bool ignore_debug_flag) -{ - ACE_TRACE ("ACE_Service_Gestalt::open_i"); - int result = 0; - ACE_Log_Msg *log_msg = ACE_LOG_MSG; - - this->no_static_svcs_ = ignore_static_svcs; - - // Record the current log setting upon entering this thread. - u_long old_process_mask = log_msg->priority_mask - (ACE_Log_Msg::PROCESS); - - u_long old_thread_mask = log_msg->priority_mask - (ACE_Log_Msg::THREAD); - -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SG::open_i - this=%@, ") - ACE_TEXT ("opened=%d, loadstatics=%d\n"), - this, this->is_opened_, this->no_static_svcs_)); -#endif - - // Guard against reentrant processing. For example, - // if the singleton gestalt (ubergestalt) was already open, - // do not open it again... - if (this->is_opened_++ != 0) - return 0; - - if (this->init_i () != 0) - return -1; - - u_long flags = log_msg->flags (); - - // Only use STDERR if the caller hasn't already set the flags. - if (flags == 0) - flags = (u_long) ACE_Log_Msg::STDERR; - - const ACE_TCHAR *key = logger_key; - - if (key == 0 || ACE_OS::strcmp (key, ACE_DEFAULT_LOGGER_KEY) == 0) - { - // Only use the static if the caller doesn't - // override it in the parameter list or if the key supplied is - // equal to the default static logger key. - key = this->logger_key_; - } - else - { - ACE_SET_BITS (flags, ACE_Log_Msg::LOGGER); - } - - if (log_msg->open (program_name, - flags, - key) == -1) - return -1; - - if (!ignore_debug_flag) - { - // If -d was included as a startup parameter, the user wants debug - // information printed during service initialization. - if (ACE::debug ()) - ACE_Log_Msg::enable_debug_messages (); - else - // The user has requested no debugging info. - ACE_Log_Msg::disable_debug_messages (); - } - - if (!ignore_default_svc_conf_file) - { - bool add_default = true; - bool has_files = this->svc_conf_file_queue_ && - !this->svc_conf_file_queue_->is_empty (); - bool has_cmdline = this->svc_queue_ && !this->svc_queue_->is_empty (); - if (has_files || has_cmdline) - { - // check if default file is already listed - ACE_TString *sptr = 0; - ACE_TString default_svc_conf (ACE_DEFAULT_SVC_CONF); - - for (ACE_SVC_QUEUE_ITERATOR iter (*this->svc_conf_file_queue_); - iter.next (sptr) != 0 && add_default; - iter.advance ()) - { - add_default = (*sptr != default_svc_conf); - } - - if (add_default) - { - FILE *fp = ACE_OS::fopen (ACE_DEFAULT_SVC_CONF, ACE_TEXT ("r")); - if (fp != 0) - ACE_OS::fclose(fp); - else - add_default = false; - - } - } - - // Load the default "svc.conf" entry. here if there weren't - // overriding -f arguments in . - if (add_default && svc_conf_file_queue_->enqueue_head - (ACE_TString (ACE_DEFAULT_SVC_CONF)) == -1) - { - errno = ENOENT; - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("enqueuing ") - ACE_DEFAULT_SVC_CONF - ACE_TEXT(" file")), - -1); - } - } - - // See if we need to load the static services. - if (this->no_static_svcs_ == 0 - && this->load_static_svcs () == -1) - result = -1; - else - { - result = this->process_directives (); - if (result != -1) - { - int temp = this->process_commandline_directives (); - if (temp == -1) - result = -1; - else result += temp; - } - } - - // Reset debugging back to the way it was when we came into - // into . - { - // Make sure to save/restore errno properly. - ACE_Errno_Guard error (errno); - - if (!ignore_debug_flag) - { - log_msg->priority_mask (old_process_mask, ACE_Log_Msg::PROCESS); - log_msg->priority_mask (old_thread_mask, ACE_Log_Msg::THREAD); - } - } - - return result; -} /* open_i () */ - - -int -ACE_Service_Gestalt::is_opened (void) -{ - return this->is_opened_; -} - -int -ACE_Service_Gestalt::process_commandline_directives (void) -{ - int result = 0; - if (this->svc_queue_ != 0) - { - ACE_TString *sptr = 0; - for (ACE_SVC_QUEUE_ITERATOR iter (*this->svc_queue_); - iter.next (sptr) != 0; - iter.advance ()) - { - // Process just a single directive. - if (this->process_directive ((sptr->fast_rep ())) != 0) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE (%P|%t) %p\n"), - ACE_TEXT ("process_directive"))); - result = -1; - } - } - - delete this->svc_queue_; - this->svc_queue_ = 0; - } - - return result; - -} /* process_commandline_directives () */ - - -int -ACE_Service_Gestalt::parse_args (int argc, ACE_TCHAR *argv[]) -{ - ACE_TRACE ("ACE_Service_Gestalt::parse_args"); - bool unused_ignore_default_svc_conf = true; - return parse_args_i (argc, argv, unused_ignore_default_svc_conf); -} - -int -ACE_Service_Gestalt::parse_args_i (int argc, - ACE_TCHAR *argv[], - bool &ignore_default_svc_conf_file) -{ - ACE_TRACE ("ACE_Service_Gestalt::parse_args_i"); - ACE_Get_Opt get_opt (argc, - argv, - ACE_TEXT ("df:k:nyS:"), - 1); // Start at argv[1]. - - if (this->init_svc_conf_file_queue () == -1) - return -1; - - for (int c; (argc != 0) && ((c = get_opt ()) != -1); ) - switch (c) - { - case 'd': - ACE::debug (1); - break; - case 'f': - if (this->svc_conf_file_queue_->enqueue_tail (ACE_TString (get_opt.opt_arg ())) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("enqueue_tail")), - -1); - ignore_default_svc_conf_file = true; - break; - case 'k': - /* - * @TODO: Is this always a static storage? Shouldn't we copy - * & gain ownership of the value? - */ - this->logger_key_ = get_opt.opt_arg (); - break; - case 'n': - this->no_static_svcs_ = 1; - break; - case 'y': - this->no_static_svcs_ = 0; - break; - case 'S': - if (this->svc_queue_ == 0) - { - ACE_NEW_RETURN (this->svc_queue_, - ACE_SVC_QUEUE, - -1); - } - - if (this->svc_queue_->enqueue_tail (ACE_TString (get_opt.opt_arg ())) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("enqueue_tail")), - -1); - break; - default: - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) %c is not a ACE_Service_Config option\n"), - c)); - } - - return 0; -} /* parse_args_i () */ - - - -// Process service configuration directives from the files queued for -// processing -int -ACE_Service_Gestalt::process_directives (bool ) -{ - ACE_TRACE ("ACE_Service_Gestalt::process_directives"); - if (this->svc_conf_file_queue_ == 0 - || this->svc_conf_file_queue_->is_empty ()) - { - return 0; - } - - ACE_TString *sptr = 0; - int failed = 0; - - // Iterate through all the svc.conf files. - for (ACE_SVC_QUEUE_ITERATOR iter (*this->svc_conf_file_queue_); - iter.next (sptr) != 0; - iter.advance ()) - { - int result = this->process_file (sptr->fast_rep ()); - if (result < 0) - return result; - failed += result; - } - - return failed; - -} /* process_directives () */ - -// Tidy up and perform last rites on a terminating ACE_Service_Gestalt. -int -ACE_Service_Gestalt::close (void) -{ - ACE_TRACE ("ACE_Service_Gestalt::close"); - - if (!this->is_opened_ || --this->is_opened_ != 0) - return 0; - - // Delete the list fo svc.conf files - delete this->svc_conf_file_queue_; - this->svc_conf_file_queue_ = 0; - - if (this->processed_static_svcs_ && - !this->processed_static_svcs_->is_empty()) - { - Processed_Static_Svc **pss = 0; - for (ACE_PROCESSED_STATIC_SVCS_ITERATOR iter (*this->processed_static_svcs_); - iter.next (pss) != 0; - iter.advance ()) - { - delete *pss; - } - } - delete this->processed_static_svcs_; - this->processed_static_svcs_ = 0; - -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SG::close - complete this=%@, repo=%@, owned=%d\n"), - this, this->repo_, this->svc_repo_is_owned_)); -#endif - - if (this->svc_repo_is_owned_) - delete this->repo_; - - this->repo_ = 0; - - return 0; -} /* close () */ - - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if !defined (__ACE_INLINE__) -#include "ace/Service_Gestalt.inl" -#endif /* __ACE_INLINE__ */ - -// Allocate a Service Manager. -ACE_FACTORY_DEFINE (ACE, ACE_Service_Manager) diff --git a/deps/acelite/ace/Service_Gestalt.h b/deps/acelite/ace/Service_Gestalt.h deleted file mode 100644 index 0a4d9b158..000000000 --- a/deps/acelite/ace/Service_Gestalt.h +++ /dev/null @@ -1,522 +0,0 @@ -// -*- C++ -*- - -//==================================================================== -/** - * @file Service_Gestalt.h - * - * @author Iliyan Jeliazkov - */ -//==================================================================== - -#ifndef ACE_SERVICE_GESTALT_H -#define ACE_SERVICE_GESTALT_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" -#include "ace/Default_Constants.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/SString.h" -#include "ace/Unbounded_Queue.h" -#include "ace/Unbounded_Set.h" -#include "ace/Service_Repository.h" -#include "ace/Singleton.h" -#include "ace/OS_NS_signal.h" -#include "ace/Synch_Traits.h" -#include "ace/Atomic_Op.h" -#include "ace/Guard_T.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -#if (ACE_USES_CLASSIC_SVC_CONF == 1) -class ACE_Service_Type_Factory; -class ACE_Location_Node; -#else -class ACE_XML_Svc_Conf; -class ACE_DLL; -#endif /* ACE_USES_CLASSIC_SVC_CONF == 1 */ - -class ACE_Static_Svc_Descriptor; -class ACE_Svc_Conf_Param; - -/** - * @class ACE_Service_Gestalt - * - * @brief Supplies common server operations for dynamic and static - * configuration of services. - * - * The Gestalt embodies the concept of configuration context. On one - * hand, it is a flat namespace, where names correspond to a Service - * Object instance. A Gestalt owns the Service Repository instance, - * which in turn owns the Service Object instances. - * - * Another aspect of a Gestalt is its responsibility for - * record-keeping and accounting for the meta-data, necessary for - * locating, removing or instantiating a service. - * - * A repository underlies an instance of a gestalt and its lifetime - * may or may not be bounded by the lifetime of the gestalt, that owns - * it. This feature is important for the derived classes and the - * Service Config in particular. - */ -class ACE_Export ACE_Service_Gestalt : private ACE_Copy_Disabled -{ -public: - enum - { - MAX_SERVICES = ACE_DEFAULT_SERVICE_REPOSITORY_SIZE - }; - - enum - { - DEFAULT_SIZE = ACE_DEFAULT_SERVICE_GESTALT_SIZE - }; - - /// Constructor either associates the instance with the process-wide - /// singleton instance of ACE_Service_Repository, or creates and - /// manages its own instance of the specified size. - ACE_Service_Gestalt (size_t size = DEFAULT_SIZE, - bool svc_repo_is_owned = true, - bool no_static_svcs = true); - - /// Perform user-specified close activities and remove dynamic - /// memory. - ~ACE_Service_Gestalt (void); - - /// Dump the state of an object. - void dump (void) const; - - /** - * Performs an open without parsing command-line arguments. The - * @a logger_key indicates where to write the logging output, which - * is typically either a STREAM pipe or a socket address. If - * @a ignore_static_svcs is true then static services are not loaded, - * otherwise, they are loaded. If @a ignore_default_svc_conf_file is - * true then the @c svc.conf configuration file will be ignored. - * Returns zero upon success, -1 if the file is not found or cannot - * be opened (errno is set accordingly), otherwise returns the - * number of errors encountered loading the services in the - * specified svc.conf configuration file. If @a ignore_debug_flag is - * true then the application is responsible for setting the - * ACE_Log_Msg::priority_mask appropriately. - */ - int open (const ACE_TCHAR program_name[], - const ACE_TCHAR *logger_key = 0, - bool ignore_static_svcs = true, - bool ignore_default_svc_conf_file = false, - bool ignore_debug_flag = false); - - /** - * This is the primary entry point into the ACE_Service_Config (the - * constructor just handles simple initializations). It parses - * arguments passed in from @a argc and @a argv parameters. The - * arguments that are valid in a call to this method include: - * - * - '-b' Option to indicate that we should be a daemon. Note that when - * this option is used, the process will be daemonized before the - * service configuration file(s) are read. During daemonization, - * (on POSIX systems) the current directory will be changed to "/" - * so the caller should either fully specify the file names, or - * execute a @c chroot() to the appropriate directory. - * @sa ACE::daemonize(). - * - '-d' Turn on debugging mode - * - '-f' Specifies a configuration file name other than the default - * svc.conf. Can be specified multiple times to use multiple files. - * If any configuration file is provided with this option then - * the default svc.conf will be ignored. - * - '-k' Specifies the rendezvous point to use for the ACE distributed - * logger. - * - '-y' Explicitly enables the use of static services. This flag - * overrides the @a ignore_static_svcs parameter value. - * - '-n' Explicitly disables the use of static services. This flag - * overrides the @a ignore_static_svcs parameter value. - * - '-p' Specifies a pathname which is used to store the process id. - * - '-s' Specifies a signal number other than SIGHUP to trigger reprocessing - * of the configuration file(s). Ignored for platforms that do not - * have POSIX signals, such as Windows. - * - '-S' Specifies a service directive string. Enclose the string in quotes - * and escape any embedded quotes with a backslash. This option - * specifies service directives without the need for a configuration - * file. Can be specified multiple times. - * - * Note: Options '-f' and '-S' complement each other. Directives - * from files and from '-S' option are processed together in the - * following order. First, the default file "./svc.conf" is - * evaluated if not ignored, then all files are processed in the - * order they are specified in '-f' @a argv parameter. Finally, all - * '-S' directive strings are executed in the order the directives - * appear in @a argv parameter. - * - * If no files or directives are added via the '-f' and '-S' - * arguments, and the default file is not ignored, it will be - * evaluated whether it exists or not, possibly causing a failure - * return. If any other directives are added then the default file - * will be evaluated only if it exists. - * - * @param argc The number of commandline arguments. - * @param argv The array with commandline arguments - * @param logger_key Indicates where to write the logging output, - * which is typically either a STREAM pipe or a - * socket address. - * @param ignore_static_svcs If true then static services are not loaded, - * otherwise, they are loaded. - * @param ignore_default_svc_conf_file If false then the @c ./svc.conf - * configuration file will be ignored. - * @param ignore_debug_flag If false then the application is responsible - * for setting the @c ACE_Log_Msg::priority_mask - * appropriately. - * - * @retval -1 A configuration file is not found or cannot - * be opened (errno is set accordingly). - * @retval 0 Success. - * @retval >0 The number of directive errors encountered while processing - * the service configuration file(s). - */ - int open (int argc, - ACE_TCHAR *argv[], - const ACE_TCHAR *logger_key = 0, - bool ignore_static_svcs = true, - bool ignore_default_svc_conf_file = false, - bool ignore_debug_flag = false); - - /// Has it been opened? Returns the difference between the times - /// open and close have been called on this instance - int is_opened (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - - /// Process one service configuration @a directive, which is passed as - /// a string. Returns the number of errors that occurred. - int process_directive (const ACE_TCHAR directive[]); - - /// Process one static service definition. - /** - * Load a new static service. - * - * @param ssd Service descriptor, see the document of - * ACE_Static_Svc_Descriptor for more details. - * - * @param force_replace If set the new service descriptor replaces - * any previous instance in the repository. - * - * @return Returns -1 if the service cannot be 'loaded'. - */ - int process_directive (const ACE_Static_Svc_Descriptor &ssd, - bool force_replace = false); - - /// Process a file containing a list of service configuration - /// directives. - int process_file (const ACE_TCHAR file[]); - - /** - * Locate an entry with @a name in the table. If @a ignore_suspended - * is set then only consider services marked as resumed. If the - * caller wants the located entry, pass back a pointer to the - * located entry via @a srp. If @a name is not found, -1 is returned. - * If @a name is found, but it is suspended and the caller wants to - * ignore suspended services a -2 is returned. - */ - int find (const ACE_TCHAR name[], - const ACE_Service_Type **srp = 0, - bool ignore_suspended = true) const; - - /** - * Handle the command-line options intended for the - * ACE_Service_Gestalt. Note that @c argv[0] is assumed to be the - * program name. - * - * The arguments that are valid in a call to this method are - * - '-d' Turn on debugging mode - * - '-f' Option to read in the list of svc.conf file names - * - '-k' Option to read a wide string where in the logger output can - * be written - * - '-y' Turn on the flag for a repository of statically - * linked services - * - '-n' Need not have a repository of statically linked services - * - '-S' Option to read in the list of services on the command-line - * Please observe the difference between options '-f' that looks - * for a list of files and here a list of services. - */ - int parse_args (int argc, ACE_TCHAR *argv[]); - - /** - * Process (or re-process) service configuration requests that are - * provided in the svc.conf file(s). Returns the number of errors - * that occurred. - */ - int process_directives (bool defunct_option = false); - - /// Tidy up and perform last rites when ACE_Service_Config is shut - /// down. This method calls @c close_svcs. Returns 0. - int close (void); - - /// Registers a service descriptor for a static service object - int insert (ACE_Static_Svc_Descriptor *stsd); - - // = Utility methods. - -#if (ACE_USES_CLASSIC_SVC_CONF == 1) - /// Dynamically link the shared object file and retrieve a pointer to - /// the designated shared object in this file. Also account for the - /// possibility to have static services registered when loading the DLL, by - /// ensuring that the dynamic service is registered before any of its - /// subordinate static services. Thus avoiding any finalization order - /// problems. - int initialize (const ACE_Service_Type_Factory *, - const ACE_TCHAR *parameters); -#endif /* (ACE_USES_CLASSIC_SVC_CONF == 1) */ - - /// Dynamically link the shared object file and retrieve a pointer to - /// the designated shared object in this file. - /// @deprecated - /// @note This is error-prone in the presense of dynamic services, - /// which in turn initialize their own static services. This method - /// will allow those static services to register *before* the dynamic - /// service that owns them. Upon finalization of the static services - /// the process will typically crash, because the dynamic service's - /// DLL may have been already released, together with the memory in - /// which the static services reside. It may not crash, for - /// instance, when the first static service to register is the same - /// as the dynamic service being loaded. You should be so lucky! - int initialize (const ACE_Service_Type *, - const ACE_TCHAR *parameters); - - /// Initialize and activate a statically @a svc_name service. - int initialize (const ACE_TCHAR *svc_name, - const ACE_TCHAR *parameters); - - /// Resume a @a svc_name that was previously suspended or has not yet - /// been resumed (e.g., a static service). - int resume (const ACE_TCHAR svc_name[]); - - /** - * Suspend @a svc_name. Note that this will not unlink the service - * from the daemon if it was dynamically linked, it will mark it as - * being suspended in the Service Repository and call the @c suspend() - * member function on the appropriate ACE_Service_Object. A - * service can be resumed later on by calling the @c resume() member - * function... - */ - int suspend (const ACE_TCHAR svc_name[]); - - /// Totally remove @a svc_name from the daemon by removing it - /// from the ACE_Reactor, and unlinking it if necessary. - int remove (const ACE_TCHAR svc_name[]); - - /** - * Using the supplied name, finds and (if needed) returns a pointer to a - * static service descriptor. Returns 0 for success and -1 for failure - */ - int find_static_svc_descriptor (const ACE_TCHAR* name, - ACE_Static_Svc_Descriptor **ssd = 0) const; - - struct Processed_Static_Svc - { - Processed_Static_Svc (const ACE_Static_Svc_Descriptor *); - ~Processed_Static_Svc (void); - ACE_TCHAR * name_; - const ACE_Static_Svc_Descriptor *assd_; - ACE_ALLOC_HOOK_DECLARE; - }; - - /// Get the current ACE_Service_Repository held by this object. - ACE_Service_Repository* current_service_repository (void); - -protected: - - int parse_args_i (int, ACE_TCHAR *argv[], - bool& ignore_default_svc_conf_file); - - /** - * Performs an open without parsing command-line arguments. The @a - * logger_key indicates where to write the logging output, which is - * typically either a STREAM pipe or a socket address. If @a - * ignore_default_svc_conf_file is non-0 then the "svc.conf" file - * will not be added by default. If @a ignore_debug_flag is non-0 - * then the application is responsible for setting the @c - * ACE_Log_Msg::priority_mask() appropriately. Returns number of - * errors that occurred on failure and 0 otherwise. - */ - int open_i (const ACE_TCHAR program_name[], - const ACE_TCHAR *logger_key = 0, - bool ignore_static_svcs = true, - bool ignore_default_svc_conf_file = false, - bool ignore_debug_flag = false); - - /// Initialize the @c svc_conf_file_queue_ if necessary. - int init_svc_conf_file_queue (void); - - /// Add the default statically-linked services to the - /// ACE_Service_Repository. - int load_static_svcs (void); - - /// Process service configuration requests that were provided on the - /// command-line. Returns the number of errors that occurred. - int process_commandline_directives (void); - - /// Process a static directive without also inserting its descriptor - /// the global table. This avoids multiple additions when processing - /// directives in non-global gestalts. - int process_directive_i (const ACE_Static_Svc_Descriptor &ssd, - bool force_replace = false); - -#if (ACE_USES_CLASSIC_SVC_CONF == 1) - /// This is the implementation function that process_directives() - /// and process_directive() both call. Returns the number of errors - /// that occurred. - int process_directives_i (ACE_Svc_Conf_Param *param); -#else - /// Helper function to dynamically link in the XML Service Configurator - /// parser. - ACE_XML_Svc_Conf* get_xml_svc_conf (ACE_DLL &d); -#endif /* ACE_USES_CLASSIC_SVC_CONF == 1 */ - - /// Dynamically link the shared object file and retrieve a pointer to - /// the designated shared object in this file. - int initialize_i (const ACE_Service_Type *sr, const ACE_TCHAR *parameters); - - const ACE_Static_Svc_Descriptor* find_processed_static_svc (const ACE_TCHAR*); - void add_processed_static_svc (const ACE_Static_Svc_Descriptor *); - - /// Performs the common initialization tasks for a new or previously - /// closed instance. Must not be virtual, as it is called from the - /// constructor. - int init_i (void); - -protected: - - /// Maintain a queue of services to be configured from the - /// command-line. - typedef ACE_Unbounded_Queue ACE_SVC_QUEUE; - typedef ACE_Unbounded_Queue_Iterator ACE_SVC_QUEUE_ITERATOR; - - /// Maintain a set of the statically linked service descriptors. - typedef ACE_Unbounded_Set - ACE_STATIC_SVCS; - - typedef ACE_Unbounded_Set_Iterator - ACE_STATIC_SVCS_ITERATOR; - - typedef ACE_Unbounded_Set - ACE_PROCESSED_STATIC_SVCS; - - typedef ACE_Unbounded_Set_Iterator - ACE_PROCESSED_STATIC_SVCS_ITERATOR; - - friend class ACE_Dynamic_Service_Base; - friend class ACE_Service_Object; - friend class ACE_Service_Config; - friend class ACE_Service_Config_Guard; - -protected: - - /// Do we own the service repository instance, or have only been - /// given a ptr to the singleton? - bool svc_repo_is_owned_; - - /// Repository size is necessary, so that we can close (which may - /// destroy the repository instance), and then re-open again. - size_t svc_repo_size_; - - /// Keep track of the number of times the instance has been - /// initialized (opened). "If so, we can't allow to be called since - /// it's not reentrant" is the original motivation, but that does not seem - /// to be the case anymore. This variable is incremented by the - /// method and decremented by the - /// method. - int is_opened_; - - /// Indicates where to write the logging output. This is typically - /// either a STREAM pipe or a socket - const ACE_TCHAR *logger_key_; - - /// Should we avoid loading the static services? - bool no_static_svcs_; - - /// Queue of services specified on the command-line. - ACE_SVC_QUEUE* svc_queue_; - - /** - * Queue of svc.conf files specified on the command-line. - * @@ This should probably be made to handle unicode filenames... - */ - ACE_SVC_QUEUE* svc_conf_file_queue_; - - /// The service repository to hold the services. - ACE_Service_Repository* repo_; - - /// Repository of statically linked services. - ACE_STATIC_SVCS* static_svcs_; - - /// Repository of statically linked services for which process - /// directive was called, but the service is not already a member of - /// the static_svcs_ list. - ACE_PROCESSED_STATIC_SVCS* processed_static_svcs_; - - /// Support for intrusive reference counting - ACE_Atomic_Op refcnt_; - - public: - static void intrusive_add_ref (ACE_Service_Gestalt*); - static void intrusive_remove_ref (ACE_Service_Gestalt*); - -}; /* class ACE_Service_Gestalt */ - - -/** - * @class ACE_Service_Type_Dynamic_Guard - * - * @brief A forward service declaration guard. - * - * Helps to resolve an issue with hybrid services, i.e. dynamic - * services, accompanied by static services in the same DLL. Only - * automatic instances of this class are supposed to exist. Those are - * created during (dynamic) service initialization and serve to: - * - * (a) Ensure the service we are loading is ordered last in the - * repository, following any other services it may cause to register, - * as part of its own registration. This is a common case when - * loading dynamic services from DLLs - there are often static - * initializers, which register static services. - * - * (b) The SDG instance destructor detects if the dynamic service - * initialized successfully and "fixes-up" all the newly registered - * static services to hold a reference to the DLL, from which they - * have originated. - */ -class ACE_Export ACE_Service_Type_Dynamic_Guard -{ -public: - ACE_Service_Type_Dynamic_Guard (ACE_Service_Repository &r, - ACE_TCHAR const *name); - - ~ACE_Service_Type_Dynamic_Guard (void); - -private: - ACE_Service_Repository & repo_; - size_t repo_begin_; - ACE_TCHAR const * const name_; - -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) -// FUZZ: disable check_for_ACE_Guard - ACE_Guard< ACE_Recursive_Thread_Mutex > repo_monitor_; -// FUZZ: enable check_for_ACE_Guard -#endif -}; - - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Service_Gestalt.inl" -#endif /* __ACE_INLINE__ */ - - -#include /**/ "ace/post.h" - -#endif /* ACE_SERVICE_GESTALT_H */ diff --git a/deps/acelite/ace/Service_Gestalt.inl b/deps/acelite/ace/Service_Gestalt.inl deleted file mode 100644 index ec46b2706..000000000 --- a/deps/acelite/ace/Service_Gestalt.inl +++ /dev/null @@ -1,75 +0,0 @@ -// -*- C++ -*- - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - - -// This is the primary entry point into the ACE_Service_Config (the -// constructor just handles simple initializations). - -ACE_INLINE int -ACE_Service_Gestalt::open (const ACE_TCHAR program_name[], - const ACE_TCHAR *logger_key, - bool ignore_static_svcs, - bool ignore_default_svc_conf, - bool ignore_debug_flag) -{ - ACE_TRACE ("ACE_Service_Gestalt::open"); - this->no_static_svcs_ = ignore_static_svcs; - - return this->open_i (program_name, - logger_key, - ignore_static_svcs, - ignore_default_svc_conf, - ignore_debug_flag); -} - -ACE_INLINE int -ACE_Service_Gestalt::open (int argc, - ACE_TCHAR *argv[], - const ACE_TCHAR *logger_key, - bool ignore_static_svcs, - bool ignore_default_svc_conf, - bool ignore_debug_flag) -{ - ACE_TRACE ("ACE_Service_Gestalt::open"); - - // Parsing argv may change no_static_svcs_ so set the default here, then - // parse, then pass the final value to open_i(). - this->no_static_svcs_ = ignore_static_svcs; - - if (this->parse_args_i (argc, - argv, - ignore_default_svc_conf) == -1) - return -1; - - return this->open_i (argv == 0 ? 0 : argv[0], - logger_key, - this->no_static_svcs_, - ignore_default_svc_conf, - ignore_debug_flag); -} - -/// Searches for a service object declaration in the local repo, only - -ACE_INLINE int -ACE_Service_Gestalt::find (const ACE_TCHAR name[], - const ACE_Service_Type **srp, - bool ignore_suspended) const -{ - // Closing the gestalt will have disassociated it from the - // repository. If the repository used to be owned by the gestalt, it - // will also have been destroyed - so just check for repo_ before - // doing anything with it. - if (this->repo_ != 0) - return this->repo_->find (name, srp, ignore_suspended); - - return 0; -} - -ACE_INLINE ACE_Service_Repository* -ACE_Service_Gestalt::current_service_repository (void) -{ - return this->repo_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Service_Manager.cpp b/deps/acelite/ace/Service_Manager.cpp deleted file mode 100644 index 547648ea5..000000000 --- a/deps/acelite/ace/Service_Manager.cpp +++ /dev/null @@ -1,431 +0,0 @@ -#include "ace/Service_Manager.h" - -#include "ace/Get_Opt.h" -#include "ace/Log_Category.h" -#include "ace/Service_Repository.h" -#include "ace/Service_Config.h" -#include "ace/Service_Types.h" -#include "ace/Reactor.h" -#include "ace/WFMO_Reactor.h" -#include "ace/OS_NS_stdio.h" -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE (ACE_Service_Manager) - -void -ACE_Service_Manager::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Service_Manager::dump"); -#endif /* ACE_HAS_DUMP */ -} - -// Static variables. - -u_short ACE_Service_Manager::DEFAULT_PORT_ = 10000; - -ACE_Service_Manager::ACE_Service_Manager (void) - : debug_ (false), - signum_ (SIGHUP) -{ - ACE_TRACE ("ACE_Service_Manager::ACE_Service_Manager"); -} - -ACE_Service_Manager::~ACE_Service_Manager (void) -{ - ACE_TRACE ("ACE_Service_Manager::~ACE_Service_Manager"); -} - -int -ACE_Service_Manager::suspend (void) -{ - ACE_TRACE ("ACE_Service_Manager::suspend"); - return ACE_Reactor::instance ()->suspend_handler (this); -} - -int -ACE_Service_Manager::resume (void) -{ - ACE_TRACE ("ACE_Service_Manager::resume"); - return ACE_Reactor::instance ()->resume_handler (this); -} - -int -ACE_Service_Manager::open (const ACE_INET_Addr &sia) -{ - ACE_TRACE ("ACE_Service_Manager::open"); - - // Reuse the listening address, even if it's already in use! - if (this->acceptor_.open (sia, 1) == -1) - { - return -1; - } - - return 0; -} - -int -ACE_Service_Manager::info (ACE_TCHAR **strp, size_t length) const -{ - ACE_TRACE ("ACE_Service_Manager::info"); - ACE_INET_Addr sa; - ACE_TCHAR buf[BUFSIZ]; - - if (this->acceptor_.get_local_addr (sa) == -1) - { - return -1; - } - - ACE_OS::snprintf (buf, BUFSIZ, - ACE_TEXT ("%d/%s %s"), - sa.get_port_number (), - ACE_TEXT ("tcp"), - ACE_TEXT ("# lists all services in the daemon\n")); - - if (*strp == 0 && (*strp = ACE_OS::strdup (buf)) == 0) - { - return -1; - } - else - { - ACE_OS::strsncpy (*strp, buf, length); - } - - return static_cast (ACE_OS::strlen (buf)); -} - -int -ACE_Service_Manager::init (int argc, ACE_TCHAR *argv[]) -{ - ACE_TRACE ("ACE_Service_Manager::init"); - ACE_INET_Addr local_addr (ACE_Service_Manager::DEFAULT_PORT_); - - //FUZZ: disable check_for_lack_ACE_OS - ACE_Get_Opt getopt (argc, argv, ACE_TEXT ("dp:s:"), 0); // Start at argv[0] - - for (int c; (c = getopt ()) != -1; ) - //FUZZ: enable check_for_lack_ACE_OS - switch (c) - { - case 'd': - this->debug_ = true; - break; - case 'p': - local_addr.set ((u_short) ACE_OS::atoi (getopt.opt_arg ())); - break; - case 's': - this->signum_ = ACE_OS::atoi (getopt.opt_arg ()); - break; - default: - break; - } - - if (this->get_handle () == ACE_INVALID_HANDLE && - this->open (local_addr) == -1) - { - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("open")), -1); - } - else if (ACE_Reactor::instance ()->register_handler - (this, - ACE_Event_Handler::ACCEPT_MASK) == -1) - { - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("registering service with ACE_Reactor\n")), - -1); - } - - return 0; -} - -int -ACE_Service_Manager::handle_close (ACE_HANDLE, ACE_Reactor_Mask) -{ - ACE_TRACE ("ACE_Service_Manager::handle_close"); - return this->acceptor_.close (); -} - -int -ACE_Service_Manager::fini (void) -{ - ACE_TRACE ("ACE_Service_Manager::fini"); - - int retv = 0; - - if (this->get_handle () != ACE_INVALID_HANDLE) - { - retv = - ACE_Reactor::instance ()->remove_handler ( - this, - ACE_Event_Handler::ACCEPT_MASK | ACE_Event_Handler::DONT_CALL); - - this->handle_close (ACE_INVALID_HANDLE, - ACE_Event_Handler::NULL_MASK); - } - - return retv; -} - -ACE_HANDLE -ACE_Service_Manager::get_handle (void) const -{ - ACE_TRACE ("ACE_Service_Manager::get_handle"); - return this->acceptor_.get_handle (); -} - -int -ACE_Service_Manager::handle_signal (int, siginfo_t *, ucontext_t *) -{ - return 0; -} - -// Determine all the services offered by this daemon and return the -// information back to the client. - -int -ACE_Service_Manager::list_services (void) -{ - ACE_TRACE ("ACE_Service_Manager::list_services"); - ACE_Service_Repository_Iterator sri (*ACE_Service_Repository::instance (), 0); - - for (const ACE_Service_Type *sr; - sri.next (sr) != 0; - sri.advance ()) - { - ssize_t len = static_cast (ACE_OS::strlen (sr->name ())) + 11; - ACE_TCHAR buf[BUFSIZ]; - ACE_TCHAR *p = buf + len; - - ACE_OS::strcpy (buf, sr->name ()); - ACE_OS::strcat (buf, (sr->active ()) ? - ACE_TEXT (" (active) ") : - ACE_TEXT (" (paused) ")); - - p[-1] = ' '; - p[0] = '\0'; - - len += sr->type ()->info (&p, sizeof buf - len); - - if (this->debug_) - { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("len = %d, info = %s%s"), - len, - buf, - buf[len - 1] == '\n' ? ACE_TEXT ("") : ACE_TEXT ("\n"))); - } - - if (len > 0) - { - ssize_t n = this->client_stream_.send_n (buf, len); - - if (n <= 0 && errno != EPIPE) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("send_n"))); - } - } - } - - return 0; -} - -// Trigger a reconfiguration of the Service Configurator via its -// svc.conf file. - -int -ACE_Service_Manager::reconfigure_services (void) -{ - ACE_TRACE ("ACE_Service_Manager::reconfigure_services"); - -#if 0 -// Send ourselves a signal! ACE_OS::kill (ACE_OS::getpid (), -// this->signum_); -#endif /* 0 */ - - // Flag the main event loop that a reconfiguration should occur. - // The next trip through the should - // pick this up and cause a reconfiguration. Note that we can't - // trigger the reconfiguration automatically since that might "pull - // the rug" out from underneath the existing services in a - // problematic way. - ACE_Service_Config::reconfig_occurred ((sig_atomic_t) 1); - return static_cast (this->client_stream_.send_n ("done\n", - sizeof ("done\n"))); -} - -// isolate the request-processing code -void -ACE_Service_Manager::process_request (ACE_TCHAR *request) -{ - ACE_TRACE("ACE_Service_Manager::process_request"); - ACE_TCHAR *p; - - // Kill trailing newlines. - for (p = request; - (*p != '\0') && (*p != '\r') && (*p != '\n'); - p++) - { - continue; - } - - *p = '\0'; - - if (ACE_OS::strcmp (request, ACE_TEXT ("help")) == 0) - { - // Return a list of the configured services. - this->list_services (); - } - else if (ACE_OS::strcmp (request, ACE_TEXT ("reconfigure") )== 0) - { - // Trigger a reconfiguration by re-reading the local file. - this->reconfigure_services (); - } - else - { - // Just process a single request passed in via the socket - // remotely. - ACE_Service_Config_Guard guard (ACE_Service_Config::global ()); - ACE_Service_Config::process_directive (request); - } - - // Additional management services may be handled here... -} - -// Accept new connection from client and carry out the service they -// request. - -int -ACE_Service_Manager::handle_input (ACE_HANDLE) -{ - ACE_TRACE ("ACE_Service_Manager::handle_input"); - - // Try to find out if the implementation of the reactor that we are - // using requires us to reset the event association for the newly - // created handle. This is because the newly created handle will - // inherit the properties of the listen handle, including its event - // associations. - bool reset_new_handle = - ACE_Reactor::instance ()->uses_event_associations (); - - if (this->acceptor_.accept (this->client_stream_, // stream - 0, // remote address - 0, // timeout - 1, // restart - reset_new_handle // reset new handler - ) == -1) - { - return -1; - } - - if (this->debug_) - { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("client_stream fd = %d\n"), - this->client_stream_.get_handle ())); - ACE_INET_Addr sa; - - if (this->client_stream_.get_remote_addr (sa) == -1) - { - return -1; - } - - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("accepted from host %C at port %d\n"), - sa.get_host_name (), - sa.get_port_number ())); - } - - ACE_TCHAR request[BUFSIZ]; - ACE_TCHAR* offset = request; - ssize_t remaining = sizeof (request); - - // Read service request from client. - - ssize_t result; - - // Keep looping until we actually get the request. Note that Win32 - // sets the socket into non-blocking mode, so we may need to loop if - // the system is heavily loaded. Read bytes into the buffer until a - // '\n' or '\r' is found in the buffer, otherwise the buffer - // contains an incomplete string. - - int error; - - do - { - result = client_stream_.recv (offset, remaining); - error = errno; - - if (result == 0 && error != EWOULDBLOCK) - { - remaining = 0; - } - - if (result >= 0) - { - if ((remaining -= result) <= 0) - { - ACELIB_DEBUG ((LM_ERROR, - ACE_TEXT ("Request buffer overflow.\n"))); - result = 0; - break; - } - - offset += result; - *offset = 0; - - if (ACE_OS::strchr (request, '\r') != 0 - || ACE_OS::strchr (request, '\n') != 0) - { - remaining = 0; - } - } - } - while ((result == -1 && error == EWOULDBLOCK) || remaining > 0); - - switch (result) - { - case -1: - if (this->debug_) - { - ACELIB_DEBUG ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("recv"))); - } - - break; - case 0: - return 0; - /* NOTREACHED */ - default: - { - ACE_Event_Handler *old_signal_handler = 0; - ACE_Reactor::instance ()->register_handler (SIGPIPE, - this, - 0, - &old_signal_handler); - - this->process_request (request); - - // Restore existing SIGPIPE handler - ACE_Reactor::instance ()->register_handler (SIGPIPE, - old_signal_handler); - } - } - - if (this->client_stream_.close () == -1 && this->debug_) - { - ACELIB_DEBUG ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("close"))); - } - - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Service_Manager.h b/deps/acelite/ace/Service_Manager.h deleted file mode 100644 index c8f941669..000000000 --- a/deps/acelite/ace/Service_Manager.h +++ /dev/null @@ -1,117 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Service_Manager.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_SERVICE_MANAGER_H -#define ACE_SERVICE_MANAGER_H -#include /**/ "ace/pre.h" - -#include "ace/SOCK_Stream.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/SOCK_Acceptor.h" -#include "ace/INET_Addr.h" -#include "ace/Service_Object.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Service_Manager - * - * @brief Provide a standard ACE service for managing all the services - * configured in an ACE_Service_Repository. - * - * This implementation is simple and just handles each client - * request one at a time. There are currently 3 types of requests: - * - List services: If the string "help" is sent, return a list of all - * the services supported by the Service Configurator. - * - Reconfigure: If the string "reconfigure" is sent trigger a - * reconfiguration, which will re-read the local file. - * - Process directive: If neither "help" nor "reconfigure" is sent, - * simply treat the incoming string as a process directive and pass - * it along to . This allows - * remote configuration via command-line instructions like - * % echo suspend My_Remote_Service | telnet hostname 3911 - * - * Each request is associated with a new connection, which is closed - * when the request is processed. In addition, you must be using the - * singleton in order to trigger - * reconfigurations. - */ -class ACE_Export ACE_Service_Manager : public ACE_Service_Object -{ -public: - /// Constructor. - ACE_Service_Manager (void); - - /// Destructor. - virtual ~ACE_Service_Manager (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - // = Perform the various meta-services. - - /// Trigger a reconfiguration of the Service Configurator by - /// re-reading its local file. - virtual int reconfigure_services (void); - - /// Determine all the services offered by this daemon and return the - /// information back to the client. - virtual int list_services (void); - - // = Dynamic linking hooks. - virtual int init (int argc, ACE_TCHAR *argv[]); - virtual int info (ACE_TCHAR **info_string, size_t length) const; - virtual int fini (void); - - // = Scheduling hooks. - virtual int suspend (void); - virtual int resume (void); - - /// Dump the state of an object. - void dump (void) const; - -protected: - int open (const ACE_INET_Addr &sia); - - // = Demultiplexing hooks. - virtual ACE_HANDLE get_handle (void) const; - virtual int handle_input (ACE_HANDLE fd); - virtual int handle_close (ACE_HANDLE fd, ACE_Reactor_Mask); - virtual int handle_signal (int signum, siginfo_t *, ucontext_t *); - - /// Handle one request. - virtual void process_request (ACE_TCHAR *request); - - /// Connection to the client (we only support one client connection - /// at a time). - ACE_SOCK_Stream client_stream_; - - /// Acceptor instance. - ACE_SOCK_Acceptor acceptor_; - - /// Keep track whether we debug or not. - bool debug_; - - /// The signal used to trigger reconfiguration. - int signum_; - - /// Default port for the Acceptor to listen on. - static u_short DEFAULT_PORT_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" -#endif /* _SERVICE_MANAGER_H */ diff --git a/deps/acelite/ace/Service_Object.cpp b/deps/acelite/ace/Service_Object.cpp deleted file mode 100644 index a16b9af04..000000000 --- a/deps/acelite/ace/Service_Object.cpp +++ /dev/null @@ -1,189 +0,0 @@ -#include "ace/config-all.h" - -#include "ace/Service_Object.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/Service_Object.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/OS_NS_stdio.h" -#include "ace/Service_Types.h" -#include "ace/DLL.h" -#include "ace/ACE.h" -#include "ace/Log_Category.h" -#if defined (ACE_OPENVMS) -# include "ace/Lib_Find.h" -#endif - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Service_Object) -ACE_ALLOC_HOOK_DEFINE(ACE_Service_Type) - -void -ACE_Service_Type::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Service_Type::dump"); -#endif /* ACE_HAS_DUMP */ - - // Using printf, since the log facility may not have been - // initialized yet. Using a "//" prefix, in case the executable - // happens to be a code generator and the output gets embedded in - // the generated C++ code. -#ifndef ACE_LACKS_STDERR - ACE_OS::fprintf(stderr, - "// [ST] dump, this=%p, name=%s, type=%p, so=%p, active=%d\n", - static_cast (this), - ACE_TEXT_ALWAYS_CHAR (this->name_), - static_cast (this->type_), - (this->type_ != 0) ? this->type_->object () : 0, - this->active_); -#endif -} - -ACE_Service_Type::ACE_Service_Type (const ACE_TCHAR *n, - ACE_Service_Type_Impl *t, - const ACE_DLL &dll, - bool active) - : name_ (0), - type_ (t), - dll_ (dll), - active_ (active), - fini_already_called_ (false) -{ - ACE_TRACE ("ACE_Service_Type::ACE_Service_Type"); - this->name (n); -} - -ACE_Service_Type::ACE_Service_Type (const ACE_TCHAR *n, - ACE_Service_Type_Impl *t, - ACE_SHLIB_HANDLE handle, - bool active) - : name_ (0), - type_ (t), - active_ (active), - fini_already_called_ (false) -{ - ACE_TRACE ("ACE_Service_Type::ACE_Service_Type"); - this->dll_.set_handle (handle); - this->name (n); -} - -ACE_Service_Type::~ACE_Service_Type (void) -{ - ACE_TRACE ("ACE_Service_Type::~ACE_Service_Type"); - this->fini (); - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(const_cast (this->name_)); -#else - delete [] const_cast (this->name_); -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -int -ACE_Service_Type::fini (void) -{ - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) ST::fini - destroying name=%s, dll=%s\n"), - this->name_, - this->dll_.dll_name_)); - - if (this->fini_already_called_) - return 0; - - this->fini_already_called_ = true; - - if (this->type_ == 0) - { - // Returning 1 currently only makes sense for dummy instances, used - // to "reserve" a spot (kind of like forward-declarations) for a - // dynamic service. This is necessary to help enforce the correct - // finalization order, when such service also has any (dependent) - // static services - - return 1; // No implementation was found. - } - - int ret = this->type_->fini (); - - // Ensure type is 0 to prevent invalid access after call to fini. - this->type_ = 0; - - // Ensure that closing the DLL is done after type_->fini() as it may - // require access to the code for the service object destructor, - // which resides in the DLL - - return (ret | this->dll_.close ()); -} - -int -ACE_Service_Type::suspend (void) const -{ - ACE_TRACE ("ACE_Service_Type::suspend"); - (const_cast (this))->active_ = false; - return this->type_->suspend (); -} - -int -ACE_Service_Type::resume (void) const -{ - ACE_TRACE ("ACE_Service_Type::resume"); - (const_cast (this))->active_ = true; - return this->type_->resume (); -} - -ACE_Service_Object::ACE_Service_Object (ACE_Reactor *r) - : ACE_Event_Handler (r) -{ - ACE_TRACE ("ACE_Service_Object::ACE_Service_Object"); -} - -ACE_Service_Object::~ACE_Service_Object (void) -{ - ACE_TRACE ("ACE_Service_Object::~ACE_Service_Object"); -} - -int -ACE_Service_Object::suspend (void) -{ - ACE_TRACE ("ACE_Service_Object::suspend"); - return 0; -} - -int -ACE_Service_Object::resume (void) -{ - ACE_TRACE ("ACE_Service_Object::resume"); - return 0; -} - -void -ACE_Service_Type::name (const ACE_TCHAR *n) -{ - ACE_TRACE ("ACE_Service_Type::name"); - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(const_cast (this->name_)); -#else - delete [] const_cast (this->name_); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - this->name_ = ACE::strnew (n); -} - -#if defined (ACE_OPENVMS) -ACE_Dynamic_Svc_Registrar::ACE_Dynamic_Svc_Registrar (const ACE_TCHAR* alloc_name, - void* svc_allocator) -{ - // register service allocator function by full name in ACE singleton registry - ACE::ldregister (alloc_name, svc_allocator); -} -#endif - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Service_Object.h b/deps/acelite/ace/Service_Object.h deleted file mode 100644 index 0fdbc13b9..000000000 --- a/deps/acelite/ace/Service_Object.h +++ /dev/null @@ -1,204 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Service_Object.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_SERVICE_OBJECT_H -#define ACE_SERVICE_OBJECT_H -#include /**/ "ace/pre.h" - -#include "ace/Shared_Object.h" -#include "ace/Svc_Conf_Tokens.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Event_Handler.h" -#include "ace/DLL.h" - -#include "ace/Service_Gestalt.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -#define ACE_Component ACE_Service_Object - -/** - * @class ACE_Service_Object - * - * @brief Provide the abstract base class common to all service - * implementations. - * - * Classes that inherit from ACE_Service_Objects are capable - * of being registered with the ACE_Reactor (due to the - * ACE_Event_Handler, as well as being dynamically linked by - * the ACE_Service_Config (due to the ACE_Shared_Object). - */ -class ACE_Export ACE_Service_Object - : public ACE_Event_Handler, - public ACE_Shared_Object -{ -public: - /// Constructor. - ACE_Service_Object (ACE_Reactor * = 0); - - /// Destructor. - virtual ~ACE_Service_Object (void); - - /// Temporarily disable a service without removing it completely. - virtual int suspend (void); - - /// Re-enable a previously suspended service. - virtual int resume (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -// Forward decl. -class ACE_Service_Type_Impl; - -/** - * @class ACE_Service_Type - * - * @brief Keeps track of information related to the various - * ACE_Service_Type_Impl subclasses. - * - * This class acts as the interface of the "Bridge" pattern. - */ -class ACE_Export ACE_Service_Type -{ -public: - enum - { - /// Delete the payload object. - DELETE_OBJ = 1, - - /// Delete the enclosing object. - DELETE_THIS = 2 - }; - - enum - { - SERVICE_OBJECT = ACE_SVC_OBJ_T, - MODULE = ACE_MODULE_T, - STREAM = ACE_STREAM_T, - INVALID_TYPE = -1 - }; - - ACE_Service_Type (const ACE_TCHAR *n, - ACE_Service_Type_Impl *o, - const ACE_DLL &dll, - bool active); - ACE_Service_Type (const ACE_TCHAR *n, - ACE_Service_Type_Impl *o, - ACE_SHLIB_HANDLE handle, - bool active); - ~ACE_Service_Type (void); - - const ACE_TCHAR *name (void) const; - void name (const ACE_TCHAR *); - - const ACE_Service_Type_Impl *type (void) const; - void type (const ACE_Service_Type_Impl *, bool active = true); - - /// Is this just a stub for the real thing? - bool is_forward_declaration (void) const; - - int suspend (void) const; - int resume (void) const; - bool active (void) const; - void active (bool turnon); - - /// Calls @c fini on @c type_ - int fini (void); - - /// Check if the service has been fini'ed. - bool fini_called (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Get to the DLL's implentation - const ACE_DLL & dll (void) const; - - /// Sets the DLL - void dll (const ACE_DLL&); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Humanly readible name of svc. - const ACE_TCHAR *name_; - - /// Pointer to C++ object that implements the svc. - const ACE_Service_Type_Impl *type_; - - /// ACE_DLL representing the shared object file (non-zero if - /// dynamically linked). - mutable ACE_DLL dll_; - - /// true if svc is currently active, otherwise false. - bool active_; - - /// true if @c fini on @c type_ has already been called, otherwise false. - bool fini_already_called_; -}; - -/** - * @class ACE_Service_Object_Ptr - * - * @brief This is a smart pointer that holds onto the associated - * ACE_Service_Object * until the current scope is left, at - * which point the object's fini() hook is called and the - * service_object_ gets deleted. - * - * This class is similar to the Standard C++ Library class - * auto_ptr. It is used in conjunction with statically linked - * ACE_Service_Objects, as shown in the ./netsvcs/server/main.cpp example. - */ -class ACE_Export ACE_Service_Object_Ptr -{ -public: - /// Acquire ownership of the @a so. - ACE_Service_Object_Ptr (ACE_Service_Object *so); - - /// Release the held ACE_Service_Object by calling its fini() hook. - ~ACE_Service_Object_Ptr (void); - - /// Smart pointer to access the underlying ACE_Service_Object. - ACE_Service_Object *operator-> (); - -private: - /// Holds the service object until we're done. - ACE_Service_Object *service_object_; -}; - -#if defined (ACE_OPENVMS) -/** - * @class ACE_Dynamic_Svc_Registrar - * - * @brief Used to register Service allocator function by its full name. - */ -class ACE_Dynamic_Svc_Registrar -{ -public: - ACE_Dynamic_Svc_Registrar (const ACE_TCHAR* alloc_name, - void* svc_allocator); -}; -#endif - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Service_Object.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_SERVICE_OBJECT_H */ diff --git a/deps/acelite/ace/Service_Object.inl b/deps/acelite/ace/Service_Object.inl deleted file mode 100644 index e5c5099f0..000000000 --- a/deps/acelite/ace/Service_Object.inl +++ /dev/null @@ -1,77 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE ACE_Service_Object_Ptr::ACE_Service_Object_Ptr (ACE_Service_Object *so) - : service_object_ (so) -{ -} - -ACE_INLINE ACE_Service_Object_Ptr::~ACE_Service_Object_Ptr (void) -{ - this->service_object_->fini (); - delete this->service_object_; -} - -ACE_INLINE ACE_Service_Object * -ACE_Service_Object_Ptr::operator-> () -{ - return this->service_object_; -} - -ACE_INLINE const ACE_TCHAR * -ACE_Service_Type::name (void) const -{ - ACE_TRACE ("ACE_Service_Type::name"); - return this->name_; -} - -ACE_INLINE const ACE_Service_Type_Impl * -ACE_Service_Type::type (void) const -{ - ACE_TRACE ("ACE_Service_Type::type"); - return this->type_; -} - -ACE_INLINE void -ACE_Service_Type::type (const ACE_Service_Type_Impl *o, bool enabled) -{ - ACE_TRACE ("ACE_Service_Type::type"); - this->type_ = o; - ((ACE_Service_Type *) this)->active_ = enabled; -} - -ACE_INLINE bool -ACE_Service_Type::active (void) const -{ - ACE_TRACE ("ACE_Service_Type::active"); - return this->active_; -} - -ACE_INLINE void -ACE_Service_Type::active (bool turnon) -{ - ACE_TRACE ("ACE_Service_Type::active"); - this->active_ = turnon; -} - -ACE_INLINE bool -ACE_Service_Type::fini_called (void) const -{ - ACE_TRACE ("ACE_Service_Type::fini_called"); - return this->fini_already_called_; -} - -ACE_INLINE const ACE_DLL & ACE_Service_Type::dll () const -{ - ACE_TRACE ("ACE_Service_Type::dll"); - return this->dll_; -} - -ACE_INLINE void ACE_Service_Type::dll (const ACE_DLL &adll) -{ - ACE_TRACE ("ACE_Service_Type::dll"); - this->dll_ = adll; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - diff --git a/deps/acelite/ace/Service_Repository.cpp b/deps/acelite/ace/Service_Repository.cpp deleted file mode 100644 index bb0755853..000000000 --- a/deps/acelite/ace/Service_Repository.cpp +++ /dev/null @@ -1,618 +0,0 @@ -#include "ace/Service_Repository.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Service_Repository.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Service_Types.h" -#include "ace/Object_Manager.h" -#include "ace/Log_Category.h" -#include "ace/ACE.h" -#include "ace/OS_NS_unistd.h" -#include "ace/OS_NS_errno.h" -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Service_Repository) - -/// Process-wide Service Repository. -ACE_Service_Repository *ACE_Service_Repository::svc_rep_ = 0; - -/// Controls whether the Service_Repository is deleted when we shut -/// down (we can only delete it safely if we created it)! -bool ACE_Service_Repository::delete_svc_rep_ = false; - -void -ACE_Service_Repository::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Service_Repository::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Service_Repository * -ACE_Service_Repository::instance (size_t size) -{ - ACE_TRACE ("ACE_Service_Repository::instance"); - - if (ACE_Service_Repository::svc_rep_ == 0) - { - // Perform Double-Checked Locking Optimization. - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, - *ACE_Static_Object_Lock::instance (), 0)); - if (ACE_Service_Repository::svc_rep_ == 0) - { - if (ACE_Object_Manager::starting_up () || - !ACE_Object_Manager::shutting_down ()) - { - ACE_NEW_RETURN (ACE_Service_Repository::svc_rep_, - ACE_Service_Repository (size), - 0); - ACE_Service_Repository::delete_svc_rep_ = true; - } - } - } - - return ACE_Service_Repository::svc_rep_; -} - -ACE_Service_Repository * -ACE_Service_Repository::instance (ACE_Service_Repository *s) -{ - ACE_TRACE ("ACE_Service_Repository::instance"); - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, - *ACE_Static_Object_Lock::instance (), 0)); - - ACE_Service_Repository *t = ACE_Service_Repository::svc_rep_; - // We can't safely delete it since we don't know who created it! - ACE_Service_Repository::delete_svc_rep_ = false; - - ACE_Service_Repository::svc_rep_ = s; - return t; -} - -void -ACE_Service_Repository::close_singleton (void) -{ - ACE_TRACE ("ACE_Service_Repository::close_singleton"); - - ACE_MT (ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon, - *ACE_Static_Object_Lock::instance ())); - - if (ACE_Service_Repository::delete_svc_rep_) - { - delete ACE_Service_Repository::svc_rep_; - ACE_Service_Repository::svc_rep_ = 0; - ACE_Service_Repository::delete_svc_rep_ = false; - } -} - -/// Initialize the Repository to a clean slate. -int -ACE_Service_Repository::open (size_t size) -{ - ACE_TRACE ("ACE_Service_Repository::open"); - - // Create a new array and swap it with the local array - array_type local_array (size); - this->service_array_.swap (local_array); - - return 0; -} - -ACE_Service_Repository::ACE_Service_Repository (size_t size) - : service_array_ (size) -{ - ACE_TRACE ("ACE_Service_Repository::ACE_Service_Repository"); -} - - -/// Finalize (call fini() and possibly delete) all the services. - -int -ACE_Service_Repository::fini (void) -{ - ACE_TRACE ("ACE_Service_Repository::fini"); - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, -1); - - int retval = 0; - // Do not be tempted to use the prefix decrement operator. Use - // postfix decrement operator since the index is unsigned and may - // wrap around the 0 - // - // debug output for empty service entries -#ifndef ACE_NLOGGING - if (ACE::debug ()) - { - for (size_t i = this->service_array_.size (); i-- != 0;) - { - ACE_Service_Type *s = - const_cast (this->service_array_[i]); - if (s == 0) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SR::fini, repo=%@ [%d] -> 0\n"), - this, - i)); - } - } -#endif - // - // Remove all the Service_Object and Stream instances - // - for (size_t i = this->service_array_.size (); i-- != 0;) - { - // the services in reverse order. - ACE_Service_Type *s = - const_cast (this->service_array_[i]); - - if (s != 0 && - s->type () != 0 && - (s->type ()->service_type () != ACE_Service_Type::MODULE)) - { -#ifndef ACE_NLOGGING - if (ACE::debug ()) - { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SR::fini, repo=%@ [%d], ") - ACE_TEXT ("name=%s, type=%@, object=%@, active=%d\n"), - this, - i, - s->name (), - s->type (), - (s->type () != 0) ? s->type ()->object () : 0, - s->active ())); - } -#endif - - // Collect any errors. - retval += s->fini (); - } - } - // - // Remove all the Module instances - // - for (size_t i = this->service_array_.size (); i-- != 0;) - { - // the services in reverse order. - ACE_Service_Type *s = - const_cast (this->service_array_[i]); - - if (s != 0 && - s->type () != 0 && - (s->type ()->service_type () == ACE_Service_Type::MODULE)) - { -#ifndef ACE_NLOGGING - if (ACE::debug ()) - { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SR::fini, repo=%@ [%d], ") - ACE_TEXT ("name=%s, type=%@, object=%@, active=%d\n"), - this, - i, - s->name (), - s->type (), - (s->type () != 0) ? s->type ()->object () : 0, - s->active ())); - } -#endif - // Collect any errors. - retval += s->fini (); - } - } - return (retval == 0) ? 0 : -1; -} - - -/// Close down all the services. -int -ACE_Service_Repository::close (void) -{ - ACE_TRACE ("ACE_Service_Repository::close"); - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, -1); - -#ifndef ACE_NLOGGING - if(ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SR::close - repo=%@, size=%d\n"), - this, - this->service_array_.size())); -#endif - - // Do not use the prefix decrement operator since the index is - // unsigned and may wrap around the 0. - for (size_t i = this->service_array_.size(); i-- != 0; ) - { - // Delete services in reverse order. - ACE_Service_Type *s = - const_cast (this->service_array_[i]); - -#ifndef ACE_NLOGGING - if(ACE::debug ()) - { - if (s == 0) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SR::close - repo=%@ [%d] -> 0\n"), - this, - i)); - else - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SR::close - repo=%@ [%d], name=%s, object=%@\n"), - this, - i, - s->name (), - s)); - } -#endif - delete s; - } - - this->service_array_.clear (); - - return 0; -} - -ACE_Service_Repository::~ACE_Service_Repository (void) -{ - ACE_TRACE ("ACE_Service_Repository::~ACE_Service_Repository"); -#ifndef ACE_NLOGGING - if(ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, "ACE (%P|%t) SR::, this=%@\n", this)); -#endif - this->close (); -} - -/// Locate an entry with @a name in the table. If @a ignore_suspended is -/// set then only consider services marked as resumed. If the caller -/// wants the located entry, pass back a pointer to the located entry -/// via @a srp. If @a name is not found -1 is returned. If @a name is -/// found, but it is suspended and the caller wants to ignore suspended -/// services a -2 is returned. Must be called with locks held. -int -ACE_Service_Repository::find_i (const ACE_TCHAR name[], - size_t &slot, - const ACE_Service_Type **srp, - bool ignore_suspended) const -{ - ACE_TRACE ("ACE_Service_Repository::find_i"); - array_type::const_iterator iter; - - for (iter = this->service_array_.begin(); iter != this->service_array_.end(); ++iter) - { - if ((*iter).second != 0 // skip any empty slots - && ACE_OS::strcmp (name, (*iter).second->name ()) == 0) - { - break; - } - } - - if (iter != this->service_array_.end ()) - { - slot = (*iter).first; - if ((*iter).second->fini_called ()) - { - if (srp != 0) - *srp = 0; - return -1; - } - - if (srp != 0) - *srp = (*iter).second; - - if (ignore_suspended - && (*iter).second->active () == 0) - return -2; - - return 0; - } - - return -1; -} - - -/// @brief Relocate (a static) service to another DLL. -/// -/// Works by having the service type keep a reference to a specific -/// DLL. No locking, caller makes sure calling it is safe. You can -/// forcefully relocate any DLLs in the given range, not only the -/// static ones - but that will cause Very Bad Things (tm) to happen. -int -ACE_Service_Repository::relocate_i (size_t begin, - size_t end, - const ACE_DLL& adll) -{ - ACE_SHLIB_HANDLE new_handle = adll.get_handle (0); - - for (size_t i = begin; i < end; i++) - { - ACE_Service_Type *type = - const_cast (this->service_array_[i]); - - ACE_SHLIB_HANDLE old_handle = (type == 0) ? ACE_SHLIB_INVALID_HANDLE - : type->dll ().get_handle (0); - -#ifndef ACE_NLOGGING - if (ACE::debug ()) - { - if (type == 0) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SR::relocate_i - repo=%@ [%d]") - ACE_TEXT (": skipping empty slot\n"), - this, - i)); - else - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SR::relocate_i - repo=%@ [%d]") - ACE_TEXT (": trying name=%s, handle: %d -> %d\n"), - this, - i, - type->name (), - old_handle, - new_handle)); - } -#endif - - if (type != 0 // skip any gaps - && old_handle == ACE_SHLIB_INVALID_HANDLE - && new_handle != old_handle) - { -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SR::relocate_i - repo=%@ [%d]") - ACE_TEXT (": relocating name=%s, handle: %d -> %d\n"), - this, - i, - type->name (), - old_handle, - new_handle)); -#endif - type->dll (adll); // ups the refcount on adll - } - } - - return 0; -} - -int -ACE_Service_Repository::find (const ACE_TCHAR name[], - const ACE_Service_Type **srp, - bool ignore_suspended) const -{ - ACE_TRACE ("ACE_Service_Repository::find"); - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, -1); - size_t ignore_location = 0; - return this->find_i (name, ignore_location, srp, ignore_suspended); -} - -/// Insert the ACE_Service_Type SR into the repository. Note that -/// services may be inserted either resumed or suspended. Using same -/// name as in an existing service causes the delete () to be called -/// for the old one, i.e. make sure @code sr is allocated on the heap! -int -ACE_Service_Repository::insert (const ACE_Service_Type *sr) -{ - ACE_TRACE ("ACE_Service_Repository::insert"); - - size_t i = 0; - int return_value = -1; - ACE_Service_Type const *s = 0; - - // Establish scope for locking while manipulating the service - // storage - { - // @TODO: Do we need a recursive mutex here? - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, - ace_mon, this->lock_, -1); - - return_value = find_i (sr->name (), i, &s, false); - - // Adding an entry. - if (s != 0) - { - this->service_array_[i] = sr; - } - else - { - // New services are always added where current_size_ points, - // because if any DLL relocation needs to happen, it will be - // performed on services with indexes between some old - // current_size_ and the new current_size_ value. See - // ACE_Service_Type_Dynamic_Guard ctor and dtor for details. - - if (i < this->service_array_.size ()) - i = this->service_array_.size (); - - this->service_array_[i] = sr; - return_value = 0; - } - } -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SR::insert - repo=%@ [%d],") - ACE_TEXT (" name=%s (%C) (type=%@, object=%@, active=%d)\n"), - this, - i, - sr->name(), - (return_value == 0 ? ((s==0) ? "new" : "replacing") : "failed"), - sr->type (), - (sr->type () != 0) ? sr->type ()->object () : 0, - sr->active ())); -#endif - - // If necessary, delete but outside the lock. (s may be 0, but - // that's okay, too) - delete s; - - if (return_value == -1) - ACE_OS::last_error (ENOSPC); - - return return_value; -} - -/// Resume a service that was previously suspended. -int -ACE_Service_Repository::resume (const ACE_TCHAR name[], - const ACE_Service_Type **srp) -{ - ACE_TRACE ("ACE_Service_Repository::resume"); - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, -1); - - size_t i = 0; - if (-1 == this->find_i (name, i, srp, 0)) - return -1; - - return this->service_array_[i]->resume (); -} - -/// Suspend a service so that it will not be considered active under -/// most circumstances by other portions of the ACE_Service_Repository. -int -ACE_Service_Repository::suspend (const ACE_TCHAR name[], - const ACE_Service_Type **srp) -{ - ACE_TRACE ("ACE_Service_Repository::suspend"); - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, -1); - size_t i = 0; - if (-1 == this->find_i (name, i, srp, 0)) - return -1; - - return this->service_array_[i]->suspend (); -} - -/** - * @brief Completely remove a @a name entry from the Repository and - * dynamically unlink it if it was originally dynamically linked. - */ -int -ACE_Service_Repository::remove (const ACE_TCHAR name[], ACE_Service_Type **ps) -{ - ACE_TRACE ("ACE_Service_Repository::remove"); - ACE_Service_Type *s = 0; - { - ACE_GUARD_RETURN (ACE_SYNCH_RECURSIVE_MUTEX, ace_mon, this->lock_, -1); - - // Not found!? - if (this->remove_i (name, &s) == -1) - return -1; - } - - if (ps != 0) - *ps = s; - else - delete s; - return 0; -} - -/** - * @brief Completely remove a @a name entry from the Repository and - * dynamically unlink it if it was originally dynamically linked. - * - * Return a ptr to the entry in @code ps. There is no locking so make - * sure you hold the repo lock when calling. - * - * Since the order of services in the Respository matters, we can't - * simply overwrite the entry being deleted with the last and - * decrement the @c current_size by 1. A good example of why the order - * matters is a dynamic service, in whose DLL there is at least one - * static service. In order to prevent SEGV during finalization, those - * static services must be finalized _before_the dynamic service that - * owns them. Otherwice the TEXT segment, containing the code for the - * static service's desructor may be unloaded with the DLL. - * - * Neither can we "pack" the array because this may happen inside the - * scope of a Service_Dynamic_Guard, which caches an index where - * loading of a DLL started in order to relocate dependent services. - */ -int -ACE_Service_Repository::remove_i (const ACE_TCHAR name[], ACE_Service_Type **ps) -{ - size_t i = 0; - if (-1 == this->find_i (name, i, 0, false)) - return -1; // Not found - - // We may need the old ptr - to be delete outside the lock! - *ps = const_cast (this->service_array_[i]); - -#ifndef ACE_NLOGGING - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("ACE (%P|%t) SR::remove_i - repo=%@ [%d],") - ACE_TEXT (" name=%s (removed) (type=%@, active=%d)\n"), - this, - i, - name, - *ps, - (*ps)->active ())); -#endif - - this->service_array_[i] = 0; // simply leave a gap - return 0; -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Service_Repository_Iterator) - -void -ACE_Service_Repository_Iterator::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Service_Repository_Iterator::dump"); -#endif /* ACE_HAS_DUMP */ -} - -/// Initializes the iterator and skips over any suspended entries at -/// the beginning of the table, if necessary. Note, you must not -/// perform destructive operations on elements during this iteration... -ACE_Service_Repository_Iterator::ACE_Service_Repository_Iterator - (ACE_Service_Repository &sr, bool ignored_suspended) - : svc_rep_ (sr), - next_ (0), - ignore_suspended_ (ignored_suspended) -{ - while (!(done() || valid())) - this->next_++; -} - -/// Obtains a pointer to the next valid service in the table. If there -/// are no more entries, returns 0, else 1. -int -ACE_Service_Repository_Iterator::next (const ACE_Service_Type *&sr) -{ - ACE_TRACE ("ACE_Service_Repository_Iterator::next"); - - if (done ()) - return 0; - - sr = this->svc_rep_.service_array_[this->next_]; - return 1; -} - -/// Advance the iterator by the proper amount. If we are ignoring -/// suspended entries and the current entry is suspended, then we must -/// skip over this entry. Otherwise, we must advance the NEXT index to -/// reference the next valid service entry. -int -ACE_Service_Repository_Iterator::advance (void) -{ - ACE_TRACE ("ACE_Service_Repository_Iterator::advance"); - - if (done()) return 0; - - do this->next_++; while (!(done () || valid ())); - - return !done(); -} - -bool -ACE_Service_Repository_Iterator::valid (void) const -{ - ACE_TRACE ("ACE_Service_Repository_Iterator::valid"); - if (!this->ignore_suspended_) - return (this->svc_rep_.service_array_[this->next_] != 0); // skip over gaps - - return (this->svc_rep_.service_array_[this->next_] != 0 - && this->svc_rep_.service_array_[this->next_]->active ()); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Service_Repository.h b/deps/acelite/ace/Service_Repository.h deleted file mode 100644 index 241e796d6..000000000 --- a/deps/acelite/ace/Service_Repository.h +++ /dev/null @@ -1,274 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Service_Repository.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_SERVICE_REPOSITORY_H -#define ACE_SERVICE_REPOSITORY_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Default_Constants.h" -#include "ace/Synch_Traits.h" -#include "ace/Array_Map.h" -#include "ace/Malloc_Base.h" -#include "ace/Recursive_Thread_Mutex.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Service_Type; -class ACE_DLL; - -#define ACE_Component_Repository ACE_Service_Repository -/** - * @class ACE_Service_Repository - * - * @brief Contains all the services offered by a Service - * Configurator-based application. - * - * This class contains a vector of ACE_Service_Types *'s and - * allows an administrative entity to centrally manage and - * control the behavior of application services. Note that if - * services are removed from the middle of the repository the - * order won't necessarily be maintained since the @a remove - * method performs compaction. However, the common case is not - * to remove services, so typically they are deleted in the - * reverse order that they were added originally. - */ -class ACE_Export ACE_Service_Repository -{ -public: - friend class ACE_Service_Repository_Iterator; - - enum - { - DEFAULT_SIZE = ACE_DEFAULT_SERVICE_REPOSITORY_SIZE - }; - - /// Initialize the repository. - ACE_Service_Repository (size_t size = DEFAULT_SIZE); - - /// Initialize the repository. - int open (size_t size = DEFAULT_SIZE); - - /// Close down the repository and free up dynamically allocated - /// resources. - ~ACE_Service_Repository (void); - - /// Close down the repository and free up dynamically allocated - /// resources. - int close (void); - - /// Finalize all the services by calling fini() and deleting - /// dynamically allocated services. - int fini (void); - - /// Get pointer to a process-wide ACE_Service_Repository. - static ACE_Service_Repository * instance - (size_t size = ACE_Service_Repository::DEFAULT_SIZE); - - /// Set pointer to a process-wide ACE_Service_Repository and return - /// existing pointer. - static ACE_Service_Repository *instance (ACE_Service_Repository *); - - /// Delete the dynamically allocated Singleton. - static void close_singleton (void); - - // = Search structure operations (all acquire locks as necessary). - - /// Insert a new service record. Returns -1 when the service repository - /// is full and 0 on success. - int insert (const ACE_Service_Type *sr); - - /** - * Locate a named entry in the service table, optionally ignoring - * suspended entries. - * - * @param name The name of the service to search for. - * @param srp Optional; if not 0, it is a pointer to a location - * to receive the ACE_Service_Type pointer for the - * located service. Meaningless if this method - * returns -1. - * @param ignore_suspended If true, the search ignores suspended services. - * - * @retval 0 Named service was located. - * @retval -1 Named service was not found. - * @retval -2 Named service was found, but is suspended and - * @a ignore_suspended is true. - */ - int find (const ACE_TCHAR name[], - const ACE_Service_Type **srp = 0, - bool ignore_suspended = true) const; - - /// Remove an existing service record. If @a sr == 0, the service record - /// is deleted before control is returned to the caller. If @a sr != 0, - /// the service's record is removed from the repository, but not deleted; - /// *sr receives the service record pointer and the caller is responsible - /// for properly disposing of it. - int remove (const ACE_TCHAR name[], ACE_Service_Type **sr = 0); - - // = Liveness control - /// Resume a service record. - int resume (const ACE_TCHAR name[], const ACE_Service_Type **srp = 0); - - /// Suspend a service record. - int suspend (const ACE_TCHAR name[], const ACE_Service_Type **srp = 0); - - /// Return the current size of the repository. - size_t current_size (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Returns a reference to the lock used by the ACE_Service_Repository - ACE_SYNCH_RECURSIVE_MUTEX &lock (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - - friend class ACE_Service_Type_Dynamic_Guard; - - /// Remove an existing service record. It requires @a sr != 0, which - /// receives the service record pointer and the caller is - /// responsible for properly disposing of it. - int remove_i (const ACE_TCHAR[], ACE_Service_Type **sr); - - /** - * Locate a named entry in the service table, optionally ignoring - * suspended entries. - * - * @param service_name The name of the service to search for. - * @param slot Receives the position index of the service if it - * is found. Contents are meaningless if this method - * returns -1. - * @param srp Optional; if not 0, it is a pointer to a location - * to receive the ACE_Service_Type pointer for the - * located service. Meaningless if this method - * returns -1. - * @param ignore_suspended If true, the search ignores suspended services. - * - * @retval 0 Named service was located; index in the table is set in - * @a slot. - * @retval -1 Named service was not found. - * @retval -2 Named service was found, but is suspended and - * @a ignore_suspended is true. - */ - int find_i (const ACE_TCHAR service_name[], - size_t &slot, - const ACE_Service_Type **srp = 0, - bool ignore_suspended = true) const; - - /// @brief Relocate (static) services to another DLL. - /// - /// If any have been registered in the context of a "forward - /// declaration" guard, those really aren't static services. Their - /// code is in the DLL's code segment, or in one of the dependent - /// DLLs. Therefore, such services need to be associated with the - /// proper DLL in order to prevent failures upon finalization. The - /// method locks the repo. - /// - /// Works by having the service type keep a reference to a specific - /// DLL. No locking, caller makes sure calling it is safe. You can - /// forcefully relocate any DLLs in the given range, not only the - /// static ones - but that will cause Very Bad Things (tm) to happen. - int relocate_i (size_t begin, - size_t end, - const ACE_DLL &adll); - - /// The typedef of the array used to store the services. -#if defined (ACE_HAS_ALLOC_HOOKS) - typedef ACE_Array_Map, ACE_Allocator_Std_Adapter > > array_type; -#else - typedef ACE_Array_Map array_type; -#endif /* ACE_HAS_ALLOC_HOOKS */ - - /// Contains all the configured services. - array_type service_array_; - - /// Pointer to a process-wide ACE_Service_Repository. - static ACE_Service_Repository *svc_rep_; - - /// Must delete the @c svc_rep_ if true. - static bool delete_svc_rep_; - - /// Synchronization variable for the ACE_Service_Repository. - mutable ACE_SYNCH_RECURSIVE_MUTEX lock_; -}; - -/** - * @class ACE_Service_Repository_Iterator - * - * @brief Iterate through the ACE_Service_Repository. - * - * Make sure not to delete entries as the iteration is going on - * since this class is not designed as a robust iterator. - */ -class ACE_Export ACE_Service_Repository_Iterator -{ -public: - /// Constructor initializes the iterator. - ACE_Service_Repository_Iterator (ACE_Service_Repository &sr, - bool ignored_suspended = true); - - /// Destructor. - ~ACE_Service_Repository_Iterator (void); - - -public: - // = Iteration methods. - - /// Pass back the @a next_item that hasn't been seen in the repository. - /// Returns 0 when all items have been seen, else 1. - int next (const ACE_Service_Type *&next_item); - - /// Returns 1 when all items have been seen, else 0. - int done (void) const; - - /// Move forward by one element in the repository. Returns 0 when all the - /// items in the set have been seen, else 1. - int advance (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - bool valid (void) const; - -private: - ACE_Service_Repository_Iterator (const ACE_Service_Repository_Iterator&); - - /// Reference to the Service Repository we are iterating over. - ACE_Service_Repository &svc_rep_; - - /// Next index location that we haven't yet seen. - size_t next_; - - /// Are we ignoring suspended services? - bool const ignore_suspended_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Service_Repository.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* _SERVICE_REPOSITORY_H */ diff --git a/deps/acelite/ace/Service_Repository.inl b/deps/acelite/ace/Service_Repository.inl deleted file mode 100644 index 9cbd38821..000000000 --- a/deps/acelite/ace/Service_Repository.inl +++ /dev/null @@ -1,41 +0,0 @@ -// -*- C++ -*- -// Returns a count of the number of currently valid entries (counting -// both resumed and suspended entries). - -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) -#include "ace/Guard_T.h" -#include "ace/Thread_Mutex.h" -#endif /* ACE_MT_SAFE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE size_t -ACE_Service_Repository::current_size (void) const -{ - ACE_TRACE ("ACE_Service_Repository::current_size"); - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, - ace_mon, - (ACE_Recursive_Thread_Mutex &) this->lock_, 0)); - return this->service_array_.size (); -} - -ACE_INLINE ACE_SYNCH_RECURSIVE_MUTEX& -ACE_Service_Repository::lock (void) const -{ - return this->lock_; -} - -ACE_INLINE int -ACE_Service_Repository_Iterator::done (void) const -{ - ACE_TRACE ("ACE_Service_Repository_Iterator::done"); - - return this->next_ >= this->svc_rep_.current_size (); -} - -ACE_INLINE -ACE_Service_Repository_Iterator::~ACE_Service_Repository_Iterator (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Service_Types.cpp b/deps/acelite/ace/Service_Types.cpp deleted file mode 100644 index 1d835685e..000000000 --- a/deps/acelite/ace/Service_Types.cpp +++ /dev/null @@ -1,463 +0,0 @@ -#include "ace/Service_Types.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Service_Types.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Stream_Modules.h" -#include "ace/Stream.h" -#include "ace/OS_NS_stdio.h" -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -typedef ACE_Stream MT_Stream; -typedef ACE_Module MT_Module; -typedef ACE_Task MT_Task; - -ACE_ALLOC_HOOK_DEFINE(ACE_Service_Type_Impl) - -void -ACE_Service_Type_Impl::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Service_Type_Impl::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Service_Type_Impl::ACE_Service_Type_Impl (void *so, - const ACE_TCHAR *s_name, - u_int f, - ACE_Service_Object_Exterminator gobbler, - int stype) - : name_ (0), - obj_ (so), - gobbler_ (gobbler), - flags_ (f), - service_type_ (stype) -{ - ACE_TRACE ("ACE_Service_Type_Impl::ACE_Service_Type_Impl"); - this->name (s_name); -} - -ACE_Service_Type_Impl::~ACE_Service_Type_Impl (void) -{ - ACE_TRACE ("ACE_Service_Type_Impl::~ACE_Service_Type_Impl"); - - // It's ok to call this, even though we may have already deleted it - // in the fini() method since it would then be NULL. -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(const_cast (this->name_)); -#else - delete [] const_cast (this->name_); -#endif /* ACE_HAS_ALLOC_HOOKS */ -} - -int -ACE_Service_Type_Impl::fini (void) const -{ - ACE_TRACE ("ACE_Service_Type_Impl::fini"); - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free(const_cast (this->name_)); -#else - delete [] const_cast (this->name_); -#endif /* ACE_HAS_ALLOC_HOOKS */ - (const_cast (this))->name_ = 0; - - if (ACE_BIT_ENABLED (this->flags_, - ACE_Service_Type::DELETE_OBJ)) - { - if (gobbler_ != 0) - gobbler_ (this->object ()); - else - // Cast to remove const-ness. - operator delete ((void *) this->object ()); - } - - if (ACE_BIT_ENABLED (this->flags_, - ACE_Service_Type::DELETE_THIS)) - delete const_cast (this); - - return 0; -} - -ACE_Service_Object_Type::ACE_Service_Object_Type (void *so, - const ACE_TCHAR *s_name, - u_int f, - ACE_Service_Object_Exterminator gobbler, - int stype) - : ACE_Service_Type_Impl (so, s_name, f, gobbler, stype) - , initialized_ (-1) -{ - ACE_TRACE ("ACE_Service_Object_Type::ACE_Service_Object_Type"); -} - -int -ACE_Service_Object_Type::init (int argc, ACE_TCHAR *argv[]) const -{ - ACE_TRACE ("ACE_Service_Object_Type::init"); - - void * const obj = this->object (); - - ACE_Service_Object * const so = - static_cast (obj); - - if (so == 0) - return -1; - - this->initialized_ = so->init (argc, argv); - - return this->initialized_; -} - -int -ACE_Service_Object_Type::fini (void) const -{ - ACE_TRACE ("ACE_Service_Object_Type::fini"); - - void * const obj = this->object (); - - ACE_Service_Object * const so = - static_cast (obj); - - // Call fini() if an only if, the object was successfuly - // initialized, i.e. init() returned 0. This is necessary to - // maintain the ctor/dtor-like semantics for init/fini. - if (so != 0 && this->initialized_ == 0) - so->fini (); - - return ACE_Service_Type_Impl::fini (); -} - -ACE_Service_Object_Type::~ACE_Service_Object_Type (void) -{ - ACE_TRACE ("ACE_Service_Object_Type::~ACE_Service_Object_Type"); -} - -int -ACE_Service_Object_Type::suspend (void) const -{ - ACE_TRACE ("ACE_Service_Object_Type::suspend"); - return static_cast (this->object ())->suspend (); -} - -int -ACE_Service_Object_Type::resume (void) const -{ - ACE_TRACE ("ACE_Service_Object_Type::resume"); - return static_cast (this->object ())->resume (); -} - -int -ACE_Service_Object_Type::info (ACE_TCHAR **str, size_t len) const -{ - ACE_TRACE ("ACE_Service_Object_Type::info"); - return static_cast (this->object ())->info (str, len); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Module_Type) - -void -ACE_Module_Type::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Module_Type::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Module_Type::ACE_Module_Type (void *m, - const ACE_TCHAR *m_name, - u_int f, - int stype) - : ACE_Service_Type_Impl (m, m_name, f, 0, stype) - , link_ (0) -{ - ACE_TRACE ("ACE_Module_Type::ACE_Module_Type"); -} - -ACE_Module_Type::~ACE_Module_Type (void) -{ - ACE_TRACE ("ACE_Module_Type::~ACE_Module_Type"); -} - -int -ACE_Module_Type::init (int argc, ACE_TCHAR *argv[]) const -{ - ACE_TRACE ("ACE_Module_Type::init"); - void *obj = this->object (); - MT_Module *mod = (MT_Module *) obj; - // - // Change the Module's name to what's in the svc.conf file. We must - // do this so the names match up so everything shuts down properly - // during the call to ACE_Stream_Type::fini which calls - // MT_Stream::remove([name]) for all the modules. If the calls to - // remove fail, we end up with a double delete during - // shutdown. Bugzilla #3847 - // - mod->name (this->name_); - MT_Task *reader = mod->reader (); - MT_Task *writer = mod->writer (); - - if (reader->init (argc, argv) == -1 - || writer->init (argc, argv) == -1) - return -1; - else - return 0; -} - -int -ACE_Module_Type::suspend (void) const -{ - ACE_TRACE ("ACE_Module_Type::suspend"); - void *obj = this->object (); - MT_Module *mod = (MT_Module *) obj; - MT_Task *reader = mod->reader (); - MT_Task *writer = mod->writer (); - - if (reader->suspend () == -1 - || writer->suspend () == -1) - return -1; - else - return 0; -} - -int -ACE_Module_Type::resume (void) const -{ - ACE_TRACE ("ACE_Module_Type::resume"); - void *obj = this->object (); - MT_Module *mod = (MT_Module *) obj; - MT_Task *reader = mod->reader (); - MT_Task *writer = mod->writer (); - - if (reader->resume () == -1 - || writer->resume () == -1) - return -1; - else - return 0; -} - -// Note, these operations are somewhat too familiar with the -// implementation of ACE_Module and ACE_Module::close... - -int -ACE_Module_Type::fini (void) const -{ - ACE_TRACE ("ACE_Module_Type::fini"); - void *obj = this->object (); - MT_Module *mod = (MT_Module *) obj; - MT_Task *reader = mod->reader (); - MT_Task *writer = mod->writer (); - - if (reader != 0) - reader->fini (); - - if (writer != 0) - writer->fini (); - - // Close the module and delete the memory. - mod->close (MT_Module::M_DELETE); - return ACE_Service_Type_Impl::fini (); -} - -int -ACE_Module_Type::info (ACE_TCHAR **str, size_t len) const -{ - ACE_TRACE ("ACE_Module_Type::info"); - ACE_TCHAR buf[BUFSIZ]; - - ACE_OS::snprintf (buf, BUFSIZ, - ACE_TEXT ("%s\t %s"), - this->name (), - ACE_TEXT ("# ACE_Module\n")); - - if (*str == 0 && (*str = ACE_OS::strdup (buf)) == 0) - return -1; - else - ACE_OS::strsncpy (*str, buf, len); - return static_cast (ACE_OS::strlen (buf)); -} - -void -ACE_Module_Type::link (ACE_Module_Type *n) -{ - ACE_TRACE ("ACE_Module_Type::link"); - this->link_ = n; -} - -ACE_Module_Type * -ACE_Module_Type::link (void) const -{ - ACE_TRACE ("ACE_Module_Type::link"); - return this->link_; -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Stream_Type) - -void -ACE_Stream_Type::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Stream_Type::dump"); -#endif /* ACE_HAS_DUMP */ -} - -int -ACE_Stream_Type::init (int, ACE_TCHAR *[]) const -{ - ACE_TRACE ("ACE_Stream_Type::init"); - return 0; -} - -int -ACE_Stream_Type::suspend (void) const -{ - ACE_TRACE ("ACE_Stream_Type::suspend"); - - for (ACE_Module_Type *m = this->head_; - m != 0; - m = m->link ()) - m->suspend (); - - return 0; -} - -int -ACE_Stream_Type::resume (void) const -{ - ACE_TRACE ("ACE_Stream_Type::resume"); - - for (ACE_Module_Type *m = this->head_; - m != 0; - m = m->link ()) - m->resume (); - - return 0; -} - -ACE_Stream_Type::ACE_Stream_Type (void *s, - const ACE_TCHAR *s_name, - u_int f, - int stype) - : ACE_Service_Type_Impl (s, s_name, f, 0, stype), - head_ (0) -{ - ACE_TRACE ("ACE_Stream_Type::ACE_Stream_Type"); -} - -ACE_Stream_Type::~ACE_Stream_Type (void) -{ - ACE_TRACE ("ACE_Stream_Type::~ACE_Stream_Type"); -} - -int -ACE_Stream_Type::info (ACE_TCHAR **str, size_t len) const -{ - ACE_TRACE ("ACE_Stream_Type::info"); - ACE_TCHAR buf[BUFSIZ]; - - ACE_OS::snprintf (buf, BUFSIZ, - ACE_TEXT ("%s\t %s"), - this->name (), - ACE_TEXT ("# STREAM\n")); - - if (*str == 0 && (*str = ACE_OS::strdup (buf)) == 0) - return -1; - else - ACE_OS::strsncpy (*str, buf, len); - return static_cast (ACE_OS::strlen (buf)); -} - -int -ACE_Stream_Type::fini (void) const -{ - ACE_TRACE ("ACE_Stream_Type::fini"); - void *obj = this->object (); - MT_Stream *str = (MT_Stream *) obj; - - for (ACE_Module_Type *m = this->head_; m != 0;) - { - ACE_Module_Type *t = m->link (); - - // Final arg is an indication to *not* delete the Module. - str->remove (m->name (), - MT_Module::M_DELETE_NONE); - m = t; - } - str->close (); - - return ACE_Service_Type_Impl::fini (); -} - -// Locate and remove from the ACE_Stream. - -int -ACE_Stream_Type::remove (ACE_Module_Type *mod) -{ - ACE_TRACE ("ACE_Stream_Type::remove"); - - ACE_Module_Type *prev = 0; - void *obj = this->object (); - MT_Stream *str = (MT_Stream *) obj; - int result = 0; - - for (ACE_Module_Type *m = this->head_; m != 0; ) - { - // We need to do this first so we don't bomb out if we delete m! - ACE_Module_Type *link = m->link (); - - if (m == mod) - { - if (prev == 0) - this->head_ = link; - else - prev->link (link); - - // Final arg is an indication to *not* delete the Module. - if (str->remove (m->name (), - MT_Module::M_DELETE_NONE) == -1) - result = -1; - - // Do not call m->fini (); as this will result in a double delete - // of the ACE_Module_type when ACE_Service_Repository::fini is called - } - else - prev = m; - - m = link; - } - - return result; -} - -int -ACE_Stream_Type::push (ACE_Module_Type *new_module) -{ - ACE_TRACE ("ACE_Stream_Type::push"); - void *obj = this->object (); - MT_Stream *str = (MT_Stream *) obj; - - new_module->link (this->head_); - this->head_ = new_module; - obj = new_module->object (); - return str->push ((MT_Module *) obj); -} - -ACE_Module_Type * -ACE_Stream_Type::find (const ACE_TCHAR *module_name) const -{ - ACE_TRACE ("ACE_Stream_Type::find"); - - for (ACE_Module_Type *m = this->head_; - m != 0; - m = m->link ()) - if (ACE_OS::strcmp (m->name (), module_name) == 0) - return m; - - return 0; -} - -// @@@ Eliminated ommented out explicit template instantiation code - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Service_Types.h b/deps/acelite/ace/Service_Types.h deleted file mode 100644 index 998cf16ed..000000000 --- a/deps/acelite/ace/Service_Types.h +++ /dev/null @@ -1,215 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Service_Types.h - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_SERVICE_TYPE_H -#define ACE_SERVICE_TYPE_H - -#include /**/ "ace/pre.h" - -#include "ace/Service_Object.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Service_Type_Impl - * - * @brief The abstract base class of the hierarchy that defines the - * contents of the ACE_Service_Repository. The subclasses of - * this class allow the configuration of ACE_Service_Objects, - * ACE_Modules, and ACE_Streams. - * - * This class provides the root of the implementation hierarchy - * of the "Bridge" pattern. It maintains a pointer to the - * appropriate type of service implementation, i.e., - * ACE_Service_Object, ACE_Module, or ACE_Stream. - */ -class ACE_Export ACE_Service_Type_Impl -{ -public: - ACE_Service_Type_Impl (void *object, - const ACE_TCHAR *s_name, - u_int flags = 0, - ACE_Service_Object_Exterminator gobbler = 0, - int stype = ACE_Service_Type::INVALID_TYPE); - virtual ~ACE_Service_Type_Impl (void); - - // = Pure virtual interface (must be defined by the subclass). - virtual int suspend (void) const = 0; - virtual int resume (void) const = 0; - virtual int init (int argc, ACE_TCHAR *argv[]) const = 0; - virtual int fini (void) const; - virtual int info (ACE_TCHAR **str, size_t len) const = 0; - - /// The pointer to the service. - void *object (void) const; - - /// Get the name of the service. - const ACE_TCHAR *name (void) const; - - /// Set the name of the service. - void name (const ACE_TCHAR *); - - /// Dump the state of an object. - void dump (void) const; - - /// get the service_type of this service - int service_type (void) const; - - /// set the service_type of this service - void service_type (int stype); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Name of the service. - const ACE_TCHAR *name_; - - /// Pointer to object that implements the service. This actually - /// points to an ACE_Service_Object, ACE_Module, or ACE_Stream. - void *obj_; - - /// Destroy function to deallocate obj_. - ACE_Service_Object_Exterminator gobbler_; - - /// Flags that control serivce behavior (particularly deletion). - u_int flags_; - - /// type of this service - /// Used to properly manage the lifecycle of ACE_Modules and ACE_Streams - /// during shutdown - int service_type_; -}; - -/** - * @class ACE_Service_Object_Type - * - * @brief Define the methods for handling the configuration of - * ACE_Service_Objects. - */ -class ACE_Export ACE_Service_Object_Type : public ACE_Service_Type_Impl -{ -public: - ACE_Service_Object_Type (void *so, - const ACE_TCHAR *name, - u_int flags = 0, - ACE_Service_Object_Exterminator gobbler = 0, - int stype = ACE_Service_Type::SERVICE_OBJECT); - - ~ACE_Service_Object_Type (void); - - // = Implement the hooks for . - virtual int suspend (void) const; - virtual int resume (void) const; - virtual int init (int argc, ACE_TCHAR *argv[]) const; - virtual int fini (void) const; - virtual int info (ACE_TCHAR **str, size_t len) const; - -private: - /// Holds the initialization status (result of object->init()) - mutable int initialized_; -}; - -/** - * @class ACE_Module_Type - * - * @brief Define the methods for handling the configuration of - * ACE_Modules. - */ -class ACE_Export ACE_Module_Type : public ACE_Service_Type_Impl -{ -public: - ACE_Module_Type (void *m, // Really an ACE_Module *. - const ACE_TCHAR *identifier, - u_int flags = 0, - int stype = ACE_Service_Type::MODULE); - - ~ACE_Module_Type (void); - - // = Implement the hooks for . - virtual int suspend (void) const; - virtual int resume (void) const; - virtual int init (int argc, ACE_TCHAR *argv[]) const; - virtual int fini (void) const; - virtual int info (ACE_TCHAR **str, size_t len) const; - - /// Get the link pointer. - ACE_Module_Type *link (void) const; - - /// Set the link pointer. - void link (ACE_Module_Type *); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Pointer to the next ACE_Module_Type in an ACE_Stream_Type. - ACE_Module_Type *link_; -}; - -/** - * @class ACE_Stream_Type - * - * @brief Define the methods for handling the configuration of - * ACE_Streams. - */ -class ACE_Export ACE_Stream_Type : public ACE_Service_Type_Impl -{ -public: - ACE_Stream_Type (void *s, // Really an ACE_Stream *. - const ACE_TCHAR *identifier, - u_int flags = 0, - int stype = ACE_Service_Type::STREAM); - - ~ACE_Stream_Type (void); - - // = Implement the hooks for . - virtual int suspend (void) const; - virtual int resume (void) const; - virtual int init (int argc, ACE_TCHAR *argv[]) const; - virtual int fini (void) const; - virtual int info (ACE_TCHAR **str, size_t len) const; - - /// Add a new ACE_Module to the top of the ACE_Stream. - int push (ACE_Module_Type *new_module); - - /// Search for @a module and remove it from the ACE_Stream. - int remove (ACE_Module_Type *module); - - /// Locate the ACE_Module with @a mod_name. - ACE_Module_Type *find (const ACE_TCHAR *module_name) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Pointer to the head of the ACE_Module list. - ACE_Module_Type *head_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Service_Types.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* _SERVICE_TYPE_H */ diff --git a/deps/acelite/ace/Service_Types.inl b/deps/acelite/ace/Service_Types.inl deleted file mode 100644 index cb13c1c4e..000000000 --- a/deps/acelite/ace/Service_Types.inl +++ /dev/null @@ -1,40 +0,0 @@ -// -*- C++ -*- -#include "ace/ACE.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE void * -ACE_Service_Type_Impl::object (void) const -{ - ACE_TRACE ("ACE_Service_Type_Impl::object"); - return this->obj_; -} - -ACE_INLINE const ACE_TCHAR * -ACE_Service_Type_Impl::name (void) const -{ - ACE_TRACE ("ACE_Service_Type_Impl::name"); - return this->name_; -} - -ACE_INLINE void -ACE_Service_Type_Impl::name (const ACE_TCHAR *n) -{ - ACE_TRACE ("ACE_Service_Type_Impl::name"); - - ACE::strdelete (const_cast (this->name_)); - this->name_ = ACE::strnew (n); -} - -ACE_INLINE int -ACE_Service_Type_Impl::service_type (void) const -{ - return service_type_; -} - -ACE_INLINE void -ACE_Service_Type_Impl::service_type (int stype) -{ - service_type_ = stype; -} -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Shared_Memory.cpp b/deps/acelite/ace/Shared_Memory.cpp deleted file mode 100644 index 7b2cba500..000000000 --- a/deps/acelite/ace/Shared_Memory.cpp +++ /dev/null @@ -1,11 +0,0 @@ -#include "ace/Shared_Memory.h" - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Shared_Memory::~ACE_Shared_Memory (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Shared_Memory.h b/deps/acelite/ace/Shared_Memory.h deleted file mode 100644 index be6970e31..000000000 --- a/deps/acelite/ace/Shared_Memory.h +++ /dev/null @@ -1,56 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Shared_Memory.h - * - * @author Doug Schmidt - */ -//========================================================================== - - -#ifndef ACE_SHARED_MEMORY_H -#define ACE_SHARED_MEMORY_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#include "ace/os_include/os_stddef.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Shared_Memory - * - * @brief This base class adapts both System V shared memory and "BSD" - * mmap to a common API. - * - * This is a very simple-minded wrapper, i.e., it really is only - * useful for allocating large contiguous chunks of shared - * memory. For a much more sophisticated version, please check - * out the class. - */ -class ACE_Export ACE_Shared_Memory -{ -public: - virtual ~ACE_Shared_Memory (void); - - // = Note that all the following methods are pure virtual. - virtual int close (void) = 0; - virtual int remove (void) = 0; - virtual void *malloc (size_t = 0) = 0; - virtual int free (void *p) = 0; - virtual size_t get_segment_size (void) const = 0; - virtual ACE_HANDLE get_id (void) const = 0; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#endif /* ACE_SHARED_MEMORY_H */ diff --git a/deps/acelite/ace/Shared_Memory_MM.cpp b/deps/acelite/ace/Shared_Memory_MM.cpp deleted file mode 100644 index c465fe0b1..000000000 --- a/deps/acelite/ace/Shared_Memory_MM.cpp +++ /dev/null @@ -1,108 +0,0 @@ -#include "ace/Shared_Memory_MM.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/Shared_Memory_MM.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Shared_Memory_MM) - -void -ACE_Shared_Memory_MM::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Shared_Memory_MM::dump"); -#endif /* ACE_HAS_DUMP */ -} - -// Creates a shared memory segment of SIZE bytes. - -ACE_Shared_Memory_MM::ACE_Shared_Memory_MM (ACE_HANDLE handle, - size_t length, - int prot, - int share, - char *addr, - ACE_OFF_T pos) - : shared_memory_ (handle, length, prot, share, addr, pos) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::ACE_Shared_Memory_MM"); -} - -ACE_Shared_Memory_MM::ACE_Shared_Memory_MM (const ACE_TCHAR *file_name, - size_t len, - int flags, - int mode, - int prot, - int share, - char *addr, - ACE_OFF_T pos) - : shared_memory_ (file_name, len, flags, mode, - prot, share, addr, pos) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::ACE_Shared_Memory_MM"); -} - -// The "do-nothing" constructor. - -ACE_Shared_Memory_MM::ACE_Shared_Memory_MM (void) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::ACE_Shared_Memory_MM"); -} - -// The overall size of the segment. - -size_t -ACE_Shared_Memory_MM::get_segment_size (void) const -{ - ACE_TRACE ("ACE_Shared_Memory_MM::get_segment_size"); - // This cast is legit since the original length in open() is an int. - return this->shared_memory_.size (); -} - -// Unmaps the shared memory segment. - -int -ACE_Shared_Memory_MM::remove (void) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::remove"); - return shared_memory_.remove (); -} - -// Closes (unmaps) the shared memory segment. - -int -ACE_Shared_Memory_MM::close (void) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::close"); - return shared_memory_.unmap (); -} - -void * -ACE_Shared_Memory_MM::malloc (size_t) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::malloc"); - void *addr = 0; - - return this->shared_memory_ (addr) == -1 ? 0 : addr; -} - -ACE_HANDLE -ACE_Shared_Memory_MM::get_id (void) const -{ - ACE_TRACE ("ACE_Shared_Memory_MM::get_id"); - return this->shared_memory_.handle (); -} - -int -ACE_Shared_Memory_MM::free (void *p) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::free"); - return p != 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Shared_Memory_MM.h b/deps/acelite/ace/Shared_Memory_MM.h deleted file mode 100644 index b0751136c..000000000 --- a/deps/acelite/ace/Shared_Memory_MM.h +++ /dev/null @@ -1,117 +0,0 @@ -/* -*- C++ -*- */ - -//============================================================================= -/** - * @file Shared_Memory_MM.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - - -#ifndef ACE_SHARED_MALLOC_MM_H -#define ACE_SHARED_MALLOC_MM_H -#include /**/ "ace/pre.h" - -#include "ace/Shared_Memory.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Mem_Map.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Shared_Memory_MM - * - * @brief Shared memory wrapper based on MMAP. - * - * This class provides a very simple-minded shared memory manager. We - * strongly recommend that you do NOT use this class. Instead, please - * use @c ACE_Malloc, which has much more powerful capabilities. - */ -class ACE_Export ACE_Shared_Memory_MM : public ACE_Shared_Memory -{ -public: - /// Default constructor. - ACE_Shared_Memory_MM (void); - - /// Constructor. - ACE_Shared_Memory_MM (ACE_HANDLE handle, - size_t length = static_cast (-1), - int prot = PROT_RDWR, - int share = ACE_MAP_PRIVATE, - char *addr = 0, - ACE_OFF_T pos = 0); - - /// Constructor. - ACE_Shared_Memory_MM (const ACE_TCHAR *file_name, - size_t length = static_cast (-1), - int flags = O_RDWR | O_CREAT, - int mode = ACE_DEFAULT_FILE_PERMS, - int prot = PROT_RDWR, - int share = ACE_MAP_SHARED, - char *addr = 0, ACE_OFF_T pos = 0); - - /// Open method. - int open (ACE_HANDLE handle, - size_t length = static_cast (-1), - int prot = PROT_RDWR, - int share = ACE_MAP_PRIVATE, - char *addr = 0, - ACE_OFF_T pos = 0); - - /// Open method. - int open (const ACE_TCHAR *file_name, - size_t length = static_cast (-1), - int flags = O_RDWR | O_CREAT, - int mode = ACE_DEFAULT_FILE_PERMS, - int prot = PROT_RDWR, - int share = ACE_MAP_SHARED, - char *addr = 0, - ACE_OFF_T pos = 0); - - /// Return the name of file that is mapped (if any). - const ACE_TCHAR *filename (void) const; - - /// Close down the shared memory segment. - virtual int close (void); - - /// Remove the shared memory segment and the underlying file. - virtual int remove (void); - - // = Allocation and deallocation methods. - /// Create a new chuck of memory containing @a size bytes. - virtual void *malloc (size_t size = 0); - - /// Free a chuck of memory allocated by - /// . - virtual int free (void *p); - - /// Return the size of the shared memory segment. - virtual size_t get_segment_size (void) const; - - /// Return the ID of the shared memory segment (i.e., an ACE_HANDLE). - virtual ACE_HANDLE get_id (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// This version is implemented with memory-mapped files. - ACE_Mem_Map shared_memory_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Shared_Memory_MM.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_SHARED_MALLOC_MM_H */ diff --git a/deps/acelite/ace/Shared_Memory_MM.inl b/deps/acelite/ace/Shared_Memory_MM.inl deleted file mode 100644 index 75762c199..000000000 --- a/deps/acelite/ace/Shared_Memory_MM.inl +++ /dev/null @@ -1,39 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Return the name of file that is mapped (if any). - -ACE_INLINE const ACE_TCHAR * -ACE_Shared_Memory_MM::filename (void) const -{ - return this->shared_memory_.filename (); -} - -ACE_INLINE int -ACE_Shared_Memory_MM::open (ACE_HANDLE handle, - size_t length, - int prot, - int share, - char *addr, - ACE_OFF_T pos) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::open"); - return shared_memory_.map (handle, length, prot, share, addr, pos); -} - -ACE_INLINE int -ACE_Shared_Memory_MM::open (const ACE_TCHAR *file_name, - size_t len, - int flags, - int mode, - int prot, - int share, - char *addr, - ACE_OFF_T pos) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::open"); - return shared_memory_.map (file_name, len, flags, mode, - prot, share, addr, pos); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Shared_Memory_Pool.cpp b/deps/acelite/ace/Shared_Memory_Pool.cpp deleted file mode 100644 index 845f595ad..000000000 --- a/deps/acelite/ace/Shared_Memory_Pool.cpp +++ /dev/null @@ -1,467 +0,0 @@ -// Shared_Memory_Pool.cpp -#include "ace/Shared_Memory_Pool.h" -#include "ace/OS_NS_sys_shm.h" -#include "ace/Log_Category.h" - - - -#if !defined (ACE_LACKS_SYSV_SHMEM) - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Shared_Memory_Pool) - -ACE_Shared_Memory_Pool_Options::ACE_Shared_Memory_Pool_Options ( - const char *base_addr, - size_t max_segments, - size_t file_perms, - ACE_OFF_T minimum_bytes, - size_t segment_size) - : base_addr_ (base_addr), - max_segments_ (max_segments), - minimum_bytes_ (minimum_bytes), - file_perms_ (file_perms), - segment_size_ (segment_size) -{ - ACE_TRACE ("ACE_Shared_Memory_Pool_Options::ACE_Shared_Memory_Pool_Options"); -} - -void -ACE_Shared_Memory_Pool::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Shared_Memory_Pool::dump"); -#endif /* ACE_HAS_DUMP */ -} - -int -ACE_Shared_Memory_Pool::in_use (ACE_OFF_T &offset, - size_t &counter) -{ -#ifndef ACE_HAS_SYSV_IPC - ACE_UNUSED_ARG (offset); - ACE_UNUSED_ARG (counter); - ACE_NOTSUP_RETURN (-1); -#else - offset = 0; - SHM_TABLE *st = reinterpret_cast (this->base_addr_); - shmid_ds buf; - - for (counter = 0; - counter < this->max_segments_ && st[counter].used_ == 1; - counter++) - { - if (ACE_OS::shmctl (st[counter].shmid_, IPC_STAT, &buf) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("(%P|%t) %p\n"), - ACE_TEXT ("shmctl")), - -1); - offset += buf.shm_segsz; - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) segment size = %d, offset = %d\n"), buf.shm_segsz, offset)); - } - return 0; -#endif -} - -int -ACE_Shared_Memory_Pool::find_seg (const void* const searchPtr, - ACE_OFF_T &offset, - size_t &counter) -{ -#ifndef ACE_HAS_SYSV_IPC - ACE_UNUSED_ARG (searchPtr); - ACE_UNUSED_ARG (offset); - ACE_UNUSED_ARG (counter); - ACE_NOTSUP_RETURN (-1); -#else - offset = 0; - SHM_TABLE *st = reinterpret_cast (this->base_addr_); - shmid_ds buf; - - for (counter = 0; - counter < this->max_segments_ - && st[counter].used_ == 1; - counter++) - { - if (ACE_OS::shmctl (st[counter].shmid_, IPC_STAT, &buf) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("(%P|%t) %p\n"), - ACE_TEXT ("shmctl")), - -1); - offset += buf.shm_segsz; - - // If segment 'counter' starts at a location greater than the - // place we are searching for. We then decrement the offset to - // the start of counter-1. (flabar@vais.net) - if (((ptrdiff_t) offset + (ptrdiff_t) (this->base_addr_)) > (ptrdiff_t) searchPtr) - { - --counter; - offset -= buf.shm_segsz; - return 0; - } - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) segment size = %d, offset = %d\n"), buf.shm_segsz, offset)); - } - - return 0; -#endif -} - -int -ACE_Shared_Memory_Pool::commit_backing_store_name (size_t rounded_bytes, - ACE_OFF_T &offset) -{ - ACE_TRACE ("ACE_Shared_Memory_Pool::commit_backing_store_name"); - - size_t counter; - SHM_TABLE *st = reinterpret_cast (this->base_addr_); - - if (this->in_use (offset, counter) == -1) - return -1; - - if (counter == this->max_segments_) - ACELIB_ERROR_RETURN ((LM_ERROR, - "exceeded max number of segments = %d, base = %u, offset = %u\n", - counter, - this->base_addr_, - static_cast(offset)), - -1); - else - { - int shmid = ACE_OS::shmget (st[counter].key_, - rounded_bytes, - this->file_perms_ | IPC_CREAT | IPC_EXCL); - if (shmid == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("(%P|%t) %p\n"), - ACE_TEXT ("shmget")), - -1); - st[counter].shmid_ = shmid; - st[counter].used_ = 1; - - void *address = (void *) (((char *) this->base_addr_) + offset); - void *shmem = ACE_OS::shmat (st[counter].shmid_, - (char *) address, - 0); - - if (shmem != address) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT("(%P|%t) %p, shmem = %u, address = %u\n"), - ACE_TEXT("shmat"), - shmem, - address), - -1); - } - return 0; -} - -/// Handle SIGSEGV and SIGBUS signals to remap shared memory properly. -int -ACE_Shared_Memory_Pool::handle_signal (int, siginfo_t *siginfo, ucontext_t *) -{ - ACE_TRACE ("ACE_Shared_Memory_Pool::handle_signal"); - - // While FreeBSD 5.X has a siginfo_t struct with a si_addr field, - // it does not define SEGV_MAPERR. -#if defined (ACE_HAS_SIGINFO_T) && !defined (ACE_LACKS_SI_ADDR) && \ - (defined (SEGV_MAPERR) || defined (SEGV_MEMERR)) - if (siginfo == 0) - return -1; - - ACE_OFF_T offset; - - // Make sure that the pointer causing the problem is within the - // range of the backing store. - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) si_signo = %d, si_code = %d, addr = %u\n"), siginfo->si_signo, siginfo->si_code, siginfo->si_addr)); - size_t counter = 0; - if (this->in_use (offset, counter) == -1) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("(%P|%t) %p\n"), - ACE_TEXT ("in_use"))); - } - else if (!(siginfo->si_code == SEGV_MAPERR - && siginfo->si_addr < (((char *) this->base_addr_) + offset) - && siginfo->si_addr >= ((char *) this->base_addr_))) - { - ACELIB_ERROR_RETURN ((LM_ERROR, - "(%P|%t) address %u out of range\n", - siginfo->si_addr), - -1); - } - - // The above if case will check to see that the address is in the - // proper range. Therefore there is a segment out there that the - // pointer wants to point into. Find the segment that someone else - // has used and attach to it (flabar@vais.net) - - counter = 0; // ret value to get shmid from the st table. - if (this->find_seg (siginfo->si_addr, offset, counter) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("(%P|%t) %p\n"), - ACE_TEXT ("in_use")), - -1); - - void *address = (void *) (((char *) this->base_addr_) + offset); - SHM_TABLE *st = reinterpret_cast (this->base_addr_); - - void *shmem = ACE_OS::shmat (st[counter].shmid_, (char *) address, 0); - - if (shmem != address) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT("(%P|%t) %p, shmem = %u, address = %u\n"), - ACE_TEXT("shmat"), - shmem, - address), - -1); - - // NOTE: this won't work if we dont have SIGINFO_T or SI_ADDR -#else - ACE_UNUSED_ARG (siginfo); -#endif /* ACE_HAS_SIGINFO_T && !defined (ACE_LACKS_SI_ADDR) */ - - return 0; -} - -ACE_Shared_Memory_Pool::ACE_Shared_Memory_Pool ( - const ACE_TCHAR *backing_store_name, - const OPTIONS *options) - : base_addr_ (0), - file_perms_ (ACE_DEFAULT_FILE_PERMS), - max_segments_ (ACE_DEFAULT_MAX_SEGMENTS), - minimum_bytes_ (0), - segment_size_ (ACE_DEFAULT_SEGMENT_SIZE) -{ - ACE_TRACE ("ACE_Shared_Memory_Pool::ACE_Shared_Memory_Pool"); - - // Only change the defaults if != 0. - if (options) - { - this->base_addr_ = - reinterpret_cast (const_cast (options->base_addr_)); - this->max_segments_ = options->max_segments_; - this->file_perms_ = options->file_perms_; - this->minimum_bytes_ = options->minimum_bytes_; - this->segment_size_ = options->segment_size_; - } - -#ifndef ACE_HAS_SYSV_IPC - ACE_UNUSED_ARG (backing_store_name); -#else - if (backing_store_name) - { - // Convert the string into a number that is used as the segment - // key. - - int segment_key = 0; -#if !defined (ACE_LACKS_SSCANF) - int result = ::sscanf (ACE_TEXT_ALWAYS_CHAR (backing_store_name), - "%d", - &segment_key); -#else - int result = 0; -#endif /* ACE_LACKS_SSCANF */ - if (result == 0 || result == EOF) - // The conversion to a number failed so hash with crc32 - // ACE::crc32 is also used in . - this->base_shm_key_ = - (key_t) ACE::crc32 (ACE_TEXT_ALWAYS_CHAR (backing_store_name)); - else - this->base_shm_key_ = segment_key; - - if (this->base_shm_key_ == IPC_PRIVATE) - // Make sure that the segment can be shared between unrelated - // processes. - this->base_shm_key_ = ACE_DEFAULT_SHM_KEY; - } - else - this->base_shm_key_ = ACE_DEFAULT_SHM_KEY; -#endif // ACE_HAS_SYSV_IPC - - if (this->signal_handler_.register_handler (SIGSEGV, this) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Sig_Handler::register_handler"))); -} - -ACE_Shared_Memory_Pool::~ACE_Shared_Memory_Pool (void) -{ -} - -// Ask system for more shared memory. - -void * -ACE_Shared_Memory_Pool::acquire (size_t nbytes, - size_t &rounded_bytes) -{ - ACE_TRACE ("ACE_Shared_Memory_Pool::acquire"); - - rounded_bytes = this->round_up (nbytes); - - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) acquiring more chunks, nbytes = %d, rounded_bytes = %d\n"), nbytes, rounded_bytes)); - - ACE_OFF_T offset; - - if (this->commit_backing_store_name (rounded_bytes, offset) == -1) - return 0; - - // ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("(%P|%t) acquired more chunks, nbytes = %d, rounded_bytes = %d\n"), nbytes, rounded_bytes)); - return ((char *) this->base_addr_) + offset; -} - -// Ask system for initial chunk of shared memory. - -void * -ACE_Shared_Memory_Pool::init_acquire (size_t nbytes, - size_t &rounded_bytes, - int &first_time) -{ - ACE_TRACE ("ACE_Shared_Memory_Pool::init_acquire"); - - ACE_OFF_T shm_table_offset = ACE::round_to_pagesize (sizeof (SHM_TABLE)); - rounded_bytes = this->round_up (nbytes > (size_t) this->minimum_bytes_ - ? nbytes - : (size_t) this->minimum_bytes_); - - // Acquire the semaphore to serialize initialization and prevent - // race conditions. - - int shmid = ACE_OS::shmget (this->base_shm_key_, - rounded_bytes + shm_table_offset, - this->file_perms_ | IPC_CREAT | IPC_EXCL); - if (shmid == -1) - { - if (errno != EEXIST) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("(%P|%t) %p\n"), - ACE_TEXT ("shmget")), - 0); - first_time = 0; - - shmid = ACE_OS::shmget (this->base_shm_key_, 0, 0); - - if (shmid == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("(%P|%t) %p\n"), - ACE_TEXT ("shmget")), - 0); - - // This implementation doesn't care if we don't get the key we - // want... - this->base_addr_ = - ACE_OS::shmat (shmid, - reinterpret_cast (this->base_addr_), - 0); - if (this->base_addr_ == reinterpret_cast (-1)) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT("(%P|%t) %p, base_addr = %u\n"), - ACE_TEXT("shmat"), - this->base_addr_), - 0); - } - else - { - first_time = 1; - - // This implementation doesn't care if we don't get the key we - // want... - this->base_addr_ = - ACE_OS::shmat (shmid, - reinterpret_cast (this->base_addr_), - 0); - if (this->base_addr_ == reinterpret_cast (-1)) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT("(%P|%t) %p, base_addr = %u\n"), - ACE_TEXT("shmat"), - this->base_addr_), 0); - - SHM_TABLE *st = reinterpret_cast (this->base_addr_); - st[0].key_ = this->base_shm_key_; - st[0].shmid_ = shmid; - - st[0].used_ = 1; - - for (size_t counter = 1; // Skip over the first entry... - counter < this->max_segments_; - counter++) - { -#ifdef ACE_HAS_SYSV_IPC - st[counter].key_ = this->base_shm_key_ + counter; -#endif - st[counter].shmid_ = 0; - st[counter].used_ = 0; - } - } - - return (void *) (((char *) this->base_addr_) + shm_table_offset); -} - -// Instruct the memory pool to release all of its resources. - -int -ACE_Shared_Memory_Pool::release (int) -{ - ACE_TRACE ("ACE_Shared_Memory_Pool::release"); - - int result = 0; - SHM_TABLE *st = reinterpret_cast (this->base_addr_); - - for (size_t counter = 0; - counter < this->max_segments_ && st[counter].used_ == 1; - counter++) - if (ACE_OS::shmctl (st[counter].shmid_, IPC_RMID, 0) == -1) - result = -1; - - return result; -} - -int -ACE_Shared_Memory_Pool::sync (ssize_t, int) -{ - ACE_TRACE ("ACE_Shared_Memory_Pool::sync"); - return 0; -} - -int -ACE_Shared_Memory_Pool::sync (void *, size_t, int) -{ - ACE_TRACE ("ACE_Shared_Memory_Pool::sync"); - return 0; -} - -int -ACE_Shared_Memory_Pool::protect (ssize_t, int) -{ - ACE_TRACE ("ACE_Shared_Memory_Pool::protect"); - return 0; -} - -int -ACE_Shared_Memory_Pool::protect (void *, size_t, int) -{ - ACE_TRACE ("ACE_Shared_Memory_Pool::protect"); - return 0; -} - -void * -ACE_Shared_Memory_Pool::base_addr (void) const -{ - ACE_TRACE ("ACE_Shared_Memory_Pool::base_addr"); - return this->base_addr_; -} - -// Implement the algorithm for rounding up the request to an -// appropriate chunksize. - -size_t -ACE_Shared_Memory_Pool::round_up (size_t nbytes) -{ - ACE_TRACE ("ACE_Shared_Memory_Pool::round_up"); - if (nbytes < this->segment_size_) - nbytes = this->segment_size_; - - return ACE::round_to_pagesize (nbytes); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* !ACE_LACKS_SYSV_SHMEM */ diff --git a/deps/acelite/ace/Shared_Memory_Pool.h b/deps/acelite/ace/Shared_Memory_Pool.h deleted file mode 100644 index d8872f18b..000000000 --- a/deps/acelite/ace/Shared_Memory_Pool.h +++ /dev/null @@ -1,208 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Shared_Memory_Pool.h - * - * @author Dougls C. Schmidt - * @author Prashant Jain - */ -//============================================================================= - -#ifndef ACE_SHARED_MEMORY_POOL_H -#define ACE_SHARED_MEMORY_POOL_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (ACE_LACKS_SYSV_SHMEM) - -#include "ace/ACE.h" -#include "ace/Event_Handler.h" -#include "ace/Sig_Handler.h" -#include "ace/os_include/sys/os_mman.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Shared_Memory_Pool_Options - * - * @brief Helper class for Shared Memory Pool constructor options. - * - * This should be a nested class, but that breaks too many - * compilers. - */ -class ACE_Export ACE_Shared_Memory_Pool_Options -{ -public: - /// Initialization method. - ACE_Shared_Memory_Pool_Options ( - const char *base_addr = ACE_DEFAULT_BASE_ADDR, - size_t max_segments = ACE_DEFAULT_MAX_SEGMENTS, - size_t file_perms = ACE_DEFAULT_FILE_PERMS, - ACE_OFF_T minimum_bytes = 0, - size_t segment_size = ACE_DEFAULT_SEGMENT_SIZE); - - /// Base address of the memory-mapped backing store. - const char *base_addr_; - - /// Number of shared memory segments to allocate. - size_t max_segments_; - - /// What the minimum bytes of the initial segment should be. - ACE_OFF_T minimum_bytes_; - - /// File permissions to use when creating/opening a segment. - size_t file_perms_; - - /// Shared memory segment size. - size_t segment_size_; -}; - -/** - * @class ACE_Shared_Memory_Pool - * - * @brief Make a memory pool that is based on System V shared memory - * (shmget(2) etc.). This implementation allows memory to be - * shared between processes. If your platform doesn't support - * System V shared memory (e.g., Win32 and many RTOS platforms - * do not) then you should use ACE_MMAP_Memory_Pool instead of this - * class. In fact, you should probably use ACE_MMAP_Memory_Pool on - * platforms that *do* support System V shared memory since it - * provides more powerful features, such as persistent backing store - * and greatly scalability. - */ -class ACE_Export ACE_Shared_Memory_Pool : public ACE_Event_Handler -{ -public: - typedef ACE_Shared_Memory_Pool_Options OPTIONS; - - /// Initialize the pool. - ACE_Shared_Memory_Pool (const ACE_TCHAR *backing_store_name = 0, - const OPTIONS *options = 0); - - virtual ~ACE_Shared_Memory_Pool (void); - - /// Ask system for initial chunk of local memory. - virtual void *init_acquire (size_t nbytes, - size_t &rounded_bytes, - int &first_time); - - /** - * Acquire at least @a nbytes from the memory pool. @a rounded_byes is - * the actual number of bytes allocated. Also acquires an internal - * semaphore that ensures proper serialization of Memory_Pool - * initialization across processes. - */ - virtual void *acquire (size_t nbytes, - size_t &rounded_bytes); - - /// Instruct the memory pool to release all of its resources. - virtual int release (int destroy = 1); - - /// Sync the memory region to the backing store starting at - /// @c this->base_addr_. - virtual int sync (ssize_t len = -1, int flags = MS_SYNC); - - /// Sync the memory region to the backing store starting at @a addr. - virtual int sync (void *addr, size_t len, int flags = MS_SYNC); - - /** - * Change the protection of the pages of the mapped region to @a prot - * starting at @c this->base_addr_ up to @a len bytes. If @a len == -1 - * then change protection of all pages in the mapped region. - */ - virtual int protect (ssize_t len = -1, int prot = PROT_RDWR); - - /// Change the protection of the pages of the mapped region to @a prot - /// starting at @a addr up to @a len bytes. - virtual int protect (void *addr, size_t len, int prot = PROT_RDWR); - - /// Return the base address of this memory pool, 0 if base_addr - /// never changes. - virtual void *base_addr (void) const; - - /// Dump the state of an object. - virtual void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Implement the algorithm for rounding up the request to an - /// appropriate chunksize. - virtual size_t round_up (size_t nbytes); - - /** - * Commits a new shared memory segment if necessary after an - * acquire() or a signal. @a offset is set to the new offset into - * the backing store. - */ - virtual int commit_backing_store_name (size_t rounded_bytes, - ACE_OFF_T &offset); - - /// Keeps track of all the segments being used. - struct SHM_TABLE - { - /// Shared memory segment key. - key_t key_; - - /// Shared memory segment internal id. - int shmid_; - - /// Is the segment currently used.; - int used_; - }; - - /** - * Base address of the shared memory segment. If this has the value - * of 0 then the OS is free to select any address, otherwise this - * value is what the OS must try to use to map the shared memory - * segment. - */ - void *base_addr_; - - /// File permissions to use when creating/opening a segment. - size_t file_perms_; - - /// Number of shared memory segments in the table. - size_t max_segments_; - - /// What the minimim bytes of the initial segment should be. - ACE_OFF_T minimum_bytes_; - - /// Shared memory segment size. - size_t segment_size_; - - /// Base shared memory key for the segment. - key_t base_shm_key_; - - /// Find the segment that contains the @a searchPtr - virtual int find_seg (const void *const searchPtr, - ACE_OFF_T &offset, - size_t &counter); - - /// Determine how much memory is currently in use. - virtual int in_use (ACE_OFF_T &offset, - size_t &counter); - - /// Handles SIGSEGV. - ACE_Sig_Handler signal_handler_; - - /// Handle SIGSEGV and SIGBUS signals to remap shared memory - /// properly. - virtual int handle_signal (int, siginfo_t *siginfo, ucontext_t *); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* !ACE_LACKS_SYSV_SHMEM */ - -#include /**/ "ace/post.h" - -#endif /* ACE_SHARED_MEMORY_POOL_H */ diff --git a/deps/acelite/ace/Shared_Memory_SV.cpp b/deps/acelite/ace/Shared_Memory_SV.cpp deleted file mode 100644 index 1a7e10b40..000000000 --- a/deps/acelite/ace/Shared_Memory_SV.cpp +++ /dev/null @@ -1,84 +0,0 @@ -#include "ace/Shared_Memory_SV.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Shared_Memory_SV.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Shared_Memory_SV) - -void -ACE_Shared_Memory_SV::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Shared_Memory_SV::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Shared_Memory_SV::ACE_Shared_Memory_SV (key_t id, - size_t length, - int create, - int perms, - void *addr, - int flags) - : shared_memory_ (id, length, create, perms, addr, flags) -{ - ACE_TRACE ("ACE_Shared_Memory_SV::ACE_Shared_Memory_SV"); -} - -// The overall size of the segment. - -size_t -ACE_Shared_Memory_SV::get_segment_size (void) const -{ - ACE_TRACE ("ACE_Shared_Memory_SV::get_segment_size"); - // This cast is ok since the 'open' method for this class allows only - // an 'int' size. Therefore, this case should not lose information. - return this->shared_memory_.get_segment_size (); -} - -// Removes the shared memory segment. - -int -ACE_Shared_Memory_SV::remove (void) -{ - ACE_TRACE ("ACE_Shared_Memory_SV::remove"); - return shared_memory_.remove (); -} - -// Closes (detaches) the shared memory segment. - -int -ACE_Shared_Memory_SV::close (void) -{ - ACE_TRACE ("ACE_Shared_Memory_SV::close"); - return shared_memory_.detach (); -} - -void * -ACE_Shared_Memory_SV::malloc (size_t) -{ - ACE_TRACE ("ACE_Shared_Memory_SV::malloc"); - return this->shared_memory_.get_segment_ptr (); -} - -ACE_HANDLE -ACE_Shared_Memory_SV::get_id (void) const -{ - ACE_TRACE ("ACE_Shared_Memory_SV::get_id"); - return this->shared_memory_.get_id (); -} - -int -ACE_Shared_Memory_SV::free (void *p) -{ - ACE_TRACE ("ACE_Shared_Memory_SV::free"); - return p != 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Shared_Memory_SV.h b/deps/acelite/ace/Shared_Memory_SV.h deleted file mode 100644 index a36f1a196..000000000 --- a/deps/acelite/ace/Shared_Memory_SV.h +++ /dev/null @@ -1,98 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Shared_Memory_SV.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - - -#ifndef ACE_SHARED_MALLOC_SV_H -#define ACE_SHARED_MALLOC_SV_H -#include /**/ "ace/pre.h" - -#include "ace/Shared_Memory.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/SV_Shared_Memory.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Shared_Memory_SV - * - * @brief Shared memory wrapper based on System V shared memory. - * - * This class provides a very simple-minded shared memory manager. We - * strongly recommend that you do NOT use this class. Instead, please - * use @c ACE_Malloc, which has much more powerful capabilities. - */ -class ACE_Export ACE_Shared_Memory_SV : public ACE_Shared_Memory -{ -public: - enum - { - ACE_CREATE = IPC_CREAT, - ACE_OPEN = 0 - }; - - ACE_Shared_Memory_SV (void); - ACE_Shared_Memory_SV (key_t id, - size_t length, - int create = ACE_Shared_Memory_SV::ACE_OPEN, - int perms = ACE_DEFAULT_FILE_PERMS, - void *addr = 0, - int flags = 0); - - int open (key_t id, - size_t length, - int create = ACE_Shared_Memory_SV::ACE_OPEN, - int perms = ACE_DEFAULT_FILE_PERMS, - void *addr = 0, - int flags = 0); - - /// Close down the shared memory segment. - virtual int close (void); - - /// Remove the underlying shared memory segment. - virtual int remove (void); - - // = Allocation and deallocation methods. - /// Create a new chuck of memory containing @a size bytes. - virtual void *malloc (size_t = 0); - - /// Free a chuck of memory allocated by . - virtual int free (void *p); - - /// Return the size of the shared memory segment. - virtual size_t get_segment_size (void) const; - - /// Return the ID of the shared memory segment (i.e., a System V - /// shared memory internal id). - virtual ACE_HANDLE get_id (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// This version is implemented with System V shared memory - /// segments. - ACE_SV_Shared_Memory shared_memory_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Shared_Memory_SV.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_SHARED_MALLOC_SV_H */ diff --git a/deps/acelite/ace/Shared_Memory_SV.inl b/deps/acelite/ace/Shared_Memory_SV.inl deleted file mode 100644 index ae7fbc6e2..000000000 --- a/deps/acelite/ace/Shared_Memory_SV.inl +++ /dev/null @@ -1,27 +0,0 @@ -// -*- C++ -*- -#include "ace/Global_Macros.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE int -ACE_Shared_Memory_SV::open (key_t id, - size_t length, - int create, - int perms, - void *addr, - int flags) -{ - ACE_TRACE ("ACE_Shared_Memory_SV::open"); - return shared_memory_.open_and_attach (id, length, create, - perms, addr, flags); -} - -// The "do-nothing" constructor. - -ACE_INLINE -ACE_Shared_Memory_SV::ACE_Shared_Memory_SV (void) -{ - ACE_TRACE ("ACE_Shared_Memory_SV::ACE_Shared_Memory_SV"); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Shared_Object.cpp b/deps/acelite/ace/Shared_Object.cpp deleted file mode 100644 index 117b32d47..000000000 --- a/deps/acelite/ace/Shared_Object.cpp +++ /dev/null @@ -1,48 +0,0 @@ -#include "ace/Shared_Object.h" -#include "ace/Global_Macros.h" -#include "ace/config-all.h" - -/* Provide the abstract base class used to access dynamic linking - facilities */ - -#if !defined (__ACE_INLINE__) -#include "ace/Shared_Object.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Initializes object when dynamic linking occurs. - -int -ACE_Shared_Object::init (int, ACE_TCHAR *[]) -{ - ACE_TRACE ("ACE_Shared_Object::init"); - return 0; -} - -// Terminates object when dynamic unlinking occurs. - -int -ACE_Shared_Object::fini (void) -{ - ACE_TRACE ("ACE_Shared_Object::fini"); - return 0; -} - -// Returns information on active object. - -int -ACE_Shared_Object::info (ACE_TCHAR **, size_t) const -{ - ACE_TRACE ("ACE_Shared_Object::info"); - return 0; -} - -// Need to give a default implementation. - -ACE_Shared_Object::~ACE_Shared_Object (void) -{ - ACE_TRACE ("ACE_Shared_Object::~ACE_Shared_Object"); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Shared_Object.h b/deps/acelite/ace/Shared_Object.h deleted file mode 100644 index 6497f292e..000000000 --- a/deps/acelite/ace/Shared_Object.h +++ /dev/null @@ -1,59 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Shared_Object.h - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_SHARED_OBJECT_H -#define ACE_SHARED_OBJECT_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/os_include/sys/os_types.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Shared_Object - * - * @brief Provide the abstract base class used to access dynamic - * linking facilities. - */ -class ACE_Export ACE_Shared_Object -{ -public: - /// Constructor - ACE_Shared_Object (void); - - /// Destructor - virtual ~ACE_Shared_Object (void); - - /// Initializes object when dynamic linking occurs. - virtual int init (int argc, ACE_TCHAR *argv[]); - - /// Terminates object when dynamic unlinking occurs. - virtual int fini (void); - - /// Returns information on a service object. - virtual int info (ACE_TCHAR **info_string, size_t length = 0) const; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Shared_Object.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* ACE_SHARED_OBJECT_H */ diff --git a/deps/acelite/ace/Shared_Object.inl b/deps/acelite/ace/Shared_Object.inl deleted file mode 100644 index 358a3fb7a..000000000 --- a/deps/acelite/ace/Shared_Object.inl +++ /dev/null @@ -1,9 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Shared_Object::ACE_Shared_Object (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Sig_Adapter.cpp b/deps/acelite/ace/Sig_Adapter.cpp deleted file mode 100644 index 18a5cc9b9..000000000 --- a/deps/acelite/ace/Sig_Adapter.cpp +++ /dev/null @@ -1,81 +0,0 @@ -#include "ace/Sig_Adapter.h" - -ACE_Sig_Adapter::ACE_Sig_Adapter (ACE_Sig_Action &sa, int sigkey) - : sigkey_ (sigkey), - type_ (SIG_ACTION), - sa_ (sa), - eh_ (0), - sig_func_ (0) -{ - // ACE_TRACE ("ACE_Sig_Adapter::ACE_Sig_Adapter"); -} - -ACE_Sig_Adapter::ACE_Sig_Adapter (ACE_Event_Handler *eh, - int sigkey) - : sigkey_ (sigkey), - type_ (ACE_HANDLER), - eh_ (eh), - sig_func_ (0) -{ - // ACE_TRACE ("ACE_Sig_Adapter::ACE_Sig_Adapter"); -} - -ACE_Sig_Adapter::ACE_Sig_Adapter (ACE_Sig_Handler_Ex sig_func, - int sigkey) - : sigkey_ (sigkey), - type_ (C_FUNCTION), - eh_ (0), - sig_func_ (sig_func) -{ - // ACE_TRACE ("ACE_Sig_Adapter::ACE_Sig_Adapter"); -} - -ACE_Sig_Adapter::~ACE_Sig_Adapter () -{ -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Sig_Adapter) - -int -ACE_Sig_Adapter::sigkey (void) -{ - ACE_TRACE ("ACE_Sig_Adapter::sigkey"); - return this->sigkey_; -} - -int -ACE_Sig_Adapter::handle_signal (int signum, - siginfo_t *siginfo, - ucontext_t *ucontext) -{ - ACE_TRACE ("ACE_Sig_Adapter::handle_signal"); - - switch (this->type_) - { - case SIG_ACTION: - { - // We have to dispatch a handler that was registered by a - // third-party library. - - ACE_Sig_Action old_disp; - - // Make sure this handler executes in the context it was - // expecting... - this->sa_.register_action (signum, &old_disp); - - ACE_Sig_Handler_Ex sig_func = ACE_Sig_Handler_Ex (this->sa_.handler ()); - - (*sig_func) (signum, siginfo, ucontext); - // Restore the original disposition. - old_disp.register_action (signum); - break; - } - case ACE_HANDLER: - this->eh_->handle_signal (signum, siginfo, ucontext); - break; - case C_FUNCTION: - (*this->sig_func_) (signum, siginfo, ucontext); - break; - } - return 0; -} diff --git a/deps/acelite/ace/Sig_Adapter.h b/deps/acelite/ace/Sig_Adapter.h deleted file mode 100644 index bb0f791a0..000000000 --- a/deps/acelite/ace/Sig_Adapter.h +++ /dev/null @@ -1,81 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Sig_Adapter.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_SIG_ADAPTER_H -#define ACE_SIG_ADAPTER_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Event_Handler.h" -#include "ace/Signal.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Sig_Adapter - * - * @brief Provide an adapter that transforms various types of signal - * handlers into the scheme used by the ACE_Reactor. - */ -class ACE_Export ACE_Sig_Adapter : public ACE_Event_Handler -{ -public: - ACE_Sig_Adapter (ACE_Sig_Action &, int sigkey); - ACE_Sig_Adapter (ACE_Event_Handler *, int sigkey); - ACE_Sig_Adapter (ACE_Sig_Handler_Ex, int sigkey = 0); - ~ACE_Sig_Adapter (void); - - /// Returns this signal key that's used to remove this from the - /// ACE_Reactor's internal table. - int sigkey (void); - - /// Called by the to dispatch the signal handler. - virtual int handle_signal (int, siginfo_t *, ucontext_t *); - - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Key for this signal handler (used to remove it). - int sigkey_; - - /// Is this an external handler or an ACE handler? - enum - { - /// We're just wrapping an ACE_Event_Handler. - ACE_HANDLER, - /// An ACE_Sig_Action. - SIG_ACTION, - /// A normal C function. - C_FUNCTION - } type_; - - // = This should be a union, but C++ won't allow that because the - // has a constructor. - /// This is an external handler (ugh). - ACE_Sig_Action sa_; - - /// This is an ACE hander. - ACE_Event_Handler *eh_; - - /// This is a normal C function. - ACE_Sig_Handler_Ex sig_func_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#endif /* ACE_SIG_ADAPTER_H */ diff --git a/deps/acelite/ace/Sig_Handler.cpp b/deps/acelite/ace/Sig_Handler.cpp deleted file mode 100644 index e91de0b4f..000000000 --- a/deps/acelite/ace/Sig_Handler.cpp +++ /dev/null @@ -1,608 +0,0 @@ -#include "ace/Sig_Handler.h" -#include "ace/Sig_Adapter.h" -#include "ace/Signal.h" -#include "ace/Recursive_Thread_Mutex.h" -#include "ace/Managed_Object.h" -#include "ace/Containers.h" -#include "ace/Guard_T.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Sig_Handler.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_HAS_SIG_C_FUNC) - -extern "C" void -ace_sig_handler_dispatch (int signum, siginfo_t *info, ucontext_t *context) -{ - ACE_TRACE ("ace_sig_handler_dispatch"); - ACE_Sig_Handler::dispatch (signum, info, context); -} - -#define ace_signal_handler_dispatcher ACE_SignalHandler(ace_sig_handler_dispatch) - -extern "C" void -ace_sig_handlers_dispatch (int signum, siginfo_t *info, ucontext_t *context) -{ - ACE_TRACE ("ace_sig_handlers_dispatch"); - ACE_Sig_Handlers::dispatch (signum, info, context); -} - -#define ace_signal_handlers_dispatcher ACE_SignalHandler(ace_sig_handlers_dispatch) - -#else -#define ace_signal_handler_dispatcher ACE_SignalHandler(ACE_Sig_Handler::dispatch) - -#define ace_signal_handlers_dispatcher ACE_SignalHandler(ACE_Sig_Handlers::dispatch) -#endif /* ACE_HAS_SIG_C_FUNC */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/// Array of Event_Handlers that will handle the signals. -ACE_Event_Handler *ACE_Sig_Handler::signal_handlers_[ACE_NSIG]; - -/// Remembers if a signal has occurred. -sig_atomic_t ACE_Sig_Handler::sig_pending_ = 0; - -ACE_ALLOC_HOOK_DEFINE(ACE_Sig_Handler) - -ACE_Sig_Handler::~ACE_Sig_Handler (void) -{ - for (int s = 1; s < ACE_NSIG; ++s) - if (ACE_Sig_Handler::signal_handlers_[s]) - ACE_Sig_Handler::remove_handler_i (s); -} - -void -ACE_Sig_Handler::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Sig_Handler::dump"); -#endif /* ACE_HAS_DUMP */ -} - -int -ACE_Sig_Handler::sig_pending (void) -{ - ACE_TRACE ("ACE_Sig_Handler::sig_pending"); - ACE_MT (ACE_Recursive_Thread_Mutex *lock = - ACE_Managed_Object::get_preallocated_object - (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); - ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, m, *lock, 0)); - return ACE_Sig_Handler::sig_pending_ != 0; -} - -void -ACE_Sig_Handler::sig_pending (int pending) -{ - ACE_TRACE ("ACE_Sig_Handler::sig_pending"); - - ACE_MT (ACE_Recursive_Thread_Mutex *lock = - ACE_Managed_Object::get_preallocated_object - (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); - ACE_GUARD (ACE_Recursive_Thread_Mutex, m, *lock)); - ACE_Sig_Handler::sig_pending_ = pending; -} - -ACE_Event_Handler * -ACE_Sig_Handler::handler (int signum) -{ - ACE_TRACE ("ACE_Sig_Handler::handler"); - ACE_MT (ACE_Recursive_Thread_Mutex *lock = - ACE_Managed_Object::get_preallocated_object - (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); - ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, m, *lock, 0)); - - if (ACE_Sig_Handler::in_range (signum)) - return ACE_Sig_Handler::signal_handlers_[signum]; - else - return 0; -} - -ACE_Event_Handler * -ACE_Sig_Handler::handler_i (int signum, - ACE_Event_Handler *new_sh) -{ - ACE_TRACE ("ACE_Sig_Handler::handler_i"); - - if (ACE_Sig_Handler::in_range (signum)) - { - ACE_Event_Handler *sh = ACE_Sig_Handler::signal_handlers_[signum]; - - ACE_Sig_Handler::signal_handlers_[signum] = new_sh; - return sh; - } - else - return 0; -} - -ACE_Event_Handler * -ACE_Sig_Handler::handler (int signum, - ACE_Event_Handler *new_sh) -{ - ACE_TRACE ("ACE_Sig_Handler::handler"); - ACE_MT (ACE_Recursive_Thread_Mutex *lock = - ACE_Managed_Object::get_preallocated_object - (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); - ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, m, *lock, 0)); - - return ACE_Sig_Handler::handler_i (signum, new_sh); -} - -/// Register an ACE_Event_Handler along with the corresponding SIGNUM. -/// This method does NOT acquire any locks, so it can be called from a -/// signal handler. -int -ACE_Sig_Handler::register_handler_i (int signum, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp, - ACE_Event_Handler **old_sh, - ACE_Sig_Action *old_disp) -{ - ACE_TRACE ("ACE_Sig_Handler::register_handler_i"); - - if (ACE_Sig_Handler::in_range (signum)) - { - ACE_Sig_Action sa; // Define a "null" action. - ACE_Event_Handler *sh = ACE_Sig_Handler::handler_i (signum, new_sh); - - // Return a pointer to the old if the user - // asks for this. - if (old_sh != 0) - *old_sh = sh; - - // Make sure that points to a valid location if the - // user doesn't care... - if (new_disp == 0) - new_disp = &sa; - - new_disp->handler (ace_signal_handler_dispatcher); -#if !defined (ACE_HAS_LYNXOS4_SIGNALS) - new_disp->flags (new_disp->flags () | SA_SIGINFO); -#endif /* ACE_HAS_LYNXOS4_SIGNALS */ - return new_disp->register_action (signum, old_disp); - } - else - return -1; -} - -/// Register an ACE_Event_Handler along with the corresponding SIGNUM. -/// This method acquires a lock, so it can't be called from a signal -/// handler, e.g., . -int -ACE_Sig_Handler::register_handler (int signum, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp, - ACE_Event_Handler **old_sh, - ACE_Sig_Action *old_disp) -{ - ACE_TRACE ("ACE_Sig_Handler::register_handler"); - ACE_MT (ACE_Recursive_Thread_Mutex *lock = - ACE_Managed_Object::get_preallocated_object - (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); - ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, m, *lock, -1)); - - return ACE_Sig_Handler::register_handler_i (signum, - new_sh, - new_disp, - old_sh, - old_disp); -} - -int -ACE_Sig_Handler::remove_handler_i (int signum, - ACE_Sig_Action *new_disp, - ACE_Sig_Action *old_disp, - int) -{ - ACE_TRACE ("ACE_Sig_Handler::remove_handler_i"); - - ACE_Sig_Action sa (SIG_DFL, (sigset_t *) 0); // Reset to default disposition. - - if (new_disp == 0) - new_disp = &sa; - - ACE_Event_Handler *eh = ACE_Sig_Handler::signal_handlers_[signum]; - ACE_Sig_Handler::signal_handlers_[signum] = 0; - - // Allow the event handler to close down if necessary. - if (eh) - { - eh->handle_close (ACE_INVALID_HANDLE, - ACE_Event_Handler::SIGNAL_MASK); - } - - // Register either the new disposition or restore the default. - return new_disp->register_action (signum, old_disp); -} - -/// Remove an ACE_Event_Handler. -int -ACE_Sig_Handler::remove_handler (int signum, - ACE_Sig_Action *new_disp, - ACE_Sig_Action *old_disp, - int) -{ - ACE_TRACE ("ACE_Sig_Handler::remove_handler"); - ACE_MT (ACE_Recursive_Thread_Mutex *lock = - ACE_Managed_Object::get_preallocated_object - (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); - ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, m, *lock, -1)); - - if (ACE_Sig_Handler::in_range (signum)) - return ACE_Sig_Handler::remove_handler_i (signum, new_disp, old_disp); - - return -1; -} - -/// Master dispatcher function that gets called by a signal handler and -/// dispatches one handler... -void -ACE_Sig_Handler::dispatch (int signum, - siginfo_t *siginfo, - ucontext_t *ucontext) -{ - ACE_TRACE ("ACE_Sig_Handler::dispatch"); - - // Save/restore errno. - ACE_Errno_Guard error (errno); - - // We can't use the call here because that acquires - // the lock, which is non-portable... - ACE_Sig_Handler::sig_pending_ = 1; - - // Darn well better be in range since the OS dispatched this... - ACE_ASSERT (ACE_Sig_Handler::in_range (signum)); - - ACE_Event_Handler *eh = ACE_Sig_Handler::signal_handlers_[signum]; - - if (eh != 0) - { - if (eh->handle_signal (signum, siginfo, ucontext) == -1) - ACE_Sig_Handler::remove_handler_i (signum); -#if defined (ACE_WIN32) - else - // Win32 is weird in the sense that it resets the signal - // disposition to SIG_DFL after a signal handler is - // dispatched. Therefore, to workaround this "feature" we - // must re-register the with - // explicitly. - ACE_Sig_Handler::register_handler_i (signum, eh); -#endif /* ACE_WIN32*/ - } -} - -// ---------------------------------------- -// The following classes are local to this file. - -// There are bugs with HP/UX's C++ compiler that prevents this stuff -// from compiling... -#define ACE_MAX_SIGNAL_HANDLERS ((size_t) 20) - -/// Keeps track of the id that uniquely identifies each registered -/// signal handler. This id can be used to cancel a timer via the -/// method. -int ACE_Sig_Handlers::sigkey_ = 0; - -/// If this is true then a 3rd party library has registered a -/// handler... -bool ACE_Sig_Handlers::third_party_sig_handler_ = false; - -// Make life easier by defining typedefs... -typedef ACE_Fixed_Set ACE_SIG_HANDLERS_SET; -typedef ACE_Fixed_Set_Iterator ACE_SIG_HANDLERS_ITERATOR; - -class ACE_Sig_Handlers_Set -{ -public: - static ACE_SIG_HANDLERS_SET *instance (int signum); - -private: - static ACE_SIG_HANDLERS_SET *sig_handlers_[ACE_NSIG]; -}; - -/* static */ -ACE_SIG_HANDLERS_SET *ACE_Sig_Handlers_Set::sig_handlers_[ACE_NSIG]; - -/* static */ -ACE_SIG_HANDLERS_SET * -ACE_Sig_Handlers_Set::instance (int signum) -{ - if (signum <= 0 || signum >= ACE_NSIG) - return 0; // This will cause problems... - else if (ACE_Sig_Handlers_Set::sig_handlers_[signum] == 0) - ACE_NEW_RETURN (ACE_Sig_Handlers_Set::sig_handlers_[signum], - ACE_SIG_HANDLERS_SET, - 0); - return ACE_Sig_Handlers_Set::sig_handlers_[signum]; -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Sig_Handlers) - -ACE_Sig_Handlers::ACE_Sig_Handlers (void) -{ -} - -void -ACE_Sig_Handlers::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Sig_Handlers::dump"); -#endif /* ACE_HAS_DUMP */ -} - -/// This is the method that does all the dirty work... The basic -/// structure of this method was devised by Detlef Becker. -int -ACE_Sig_Handlers::register_handler (int signum, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp, - ACE_Event_Handler **, - ACE_Sig_Action *old_disp) -{ - ACE_TRACE ("ACE_Sig_Handlers::register_handler"); - ACE_MT (ACE_Recursive_Thread_Mutex *lock = - ACE_Managed_Object::get_preallocated_object - (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); - ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, m, *lock, -1)); - - if (ACE_Sig_Handler::in_range (signum)) - { - ACE_Sig_Adapter *ace_sig_adapter = 0; // Our signal handler. - ACE_Sig_Adapter *extern_sh = 0; // An external signal handler. - ACE_Sig_Action sa; - - // Get current signal disposition. - sa.retrieve_action (signum); - - // Check whether we are already in control of the signal - // handling disposition... - - if (!(sa.handler () == ace_signal_handlers_dispatcher - || sa.handler () == ACE_SignalHandler (SIG_IGN) - || sa.handler () == ACE_SignalHandler (SIG_DFL))) - { - // Drat, a 3rd party library has already installed a signal ;-( - - // Upto here we never disabled RESTART_MODE. Thus, - // RESTART_MODE can only be changed by 3rd party libraries. - - if (ACE_BIT_DISABLED (sa.flags (), SA_RESTART) - && ACE_Sig_Handlers::third_party_sig_handler_) - // Toggling is disallowed since we might break 3rd party - // code. - return -1; - - // Note that we've seen a 3rd party handler... - ACE_Sig_Handlers::third_party_sig_handler_ = true; - - // Create a new 3rd party disposition, remembering its - // preferred signal blocking etc...; - ACE_NEW_RETURN (extern_sh, - ACE_Sig_Adapter (sa, - ++ACE_Sig_Handlers::sigkey_), - -1); - // Add the external signal handler to the set of handlers - // for this signal. - if (ACE_Sig_Handlers_Set::instance (signum)->insert (extern_sh) == -1) - { - delete extern_sh; - return -1; - } - } - // Add our new handler at this point. - ACE_NEW_RETURN (ace_sig_adapter, - ACE_Sig_Adapter (new_sh, - ++ACE_Sig_Handlers::sigkey_), - -1); - - // Add the ACE signal handler to the set of handlers for this - // signal (make sure it goes before the external one if there is - // one of these). - int result = ACE_Sig_Handlers_Set::instance (signum)->insert (ace_sig_adapter); - - if (result == -1) - { - // We couldn't reinstall our handler, so let's pretend like - // none of this happened... - if (extern_sh) - { - ACE_Sig_Handlers_Set::instance (signum)->remove (extern_sh); - delete extern_sh; - } - delete ace_sig_adapter; - return -1; - } - // If ACE_Sig_Handlers::dispatch() was set we're done. - else if (sa.handler () == ace_signal_handlers_dispatcher) - return ace_sig_adapter->sigkey (); - - // Otherwise, we need to register our handler function so that - // all signals will be dispatched through ACE. - else - { - // Make sure that new_disp points to a valid location if the - // user doesn't care... - if (new_disp == 0) - new_disp = &sa; - - new_disp->handler (ace_signal_handlers_dispatcher); - - // Default is to restart signal handlers. - new_disp->flags (new_disp->flags () | SA_RESTART); -#if !defined (ACE_HAS_LYNXOS4_SIGNALS) - new_disp->flags (new_disp->flags () | SA_SIGINFO); -#endif /* ACE_HAS_LYNXOS4_SIGNALS */ - - // Finally install (possibly reinstall) the ACE signal - // handler disposition with the SA_RESTART mode enabled. - if (new_disp->register_action (signum, old_disp) == -1) - { - // Yikes, lots of roll back at this point... - ACE_Sig_Handlers_Set::instance (signum)->remove (ace_sig_adapter); - delete ace_sig_adapter; - - if (extern_sh) - { - ACE_Sig_Handlers_Set::instance (signum)->remove (extern_sh); - delete extern_sh; - } - return -1; - } - else // Return the signal key so that programs can cancel this - // handler if they want! - return ace_sig_adapter->sigkey (); - } - } - - return -1; -} - -/// Remove the ACE_Event_Handler currently associated with @a signum. -/// Install the new disposition (if given) and return the previous -/// disposition (if desired by the caller). Returns 0 on success and -// -1 if @a signum is invalid. -int -ACE_Sig_Handlers::remove_handler (int signum, - ACE_Sig_Action *new_disp, - ACE_Sig_Action *old_disp, - int sigkey) -{ - ACE_TRACE ("ACE_Sig_Handlers::remove_handler"); - ACE_MT (ACE_Recursive_Thread_Mutex *lock = - ACE_Managed_Object::get_preallocated_object - (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); - ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, m, *lock, -1)); - - if (ACE_Sig_Handler::in_range (signum)) - { - ACE_SIG_HANDLERS_SET *handler_set = - ACE_Sig_Handlers_Set::instance (signum); - - ACE_SIG_HANDLERS_ITERATOR handler_iterator (*handler_set); - - // Iterate through the set of handlers for this signal. - for (ACE_Event_Handler **eh; - handler_iterator.next (eh) != 0; - ) - { - // Type-safe downcast would be nice here... - ACE_Sig_Adapter *sh = (ACE_Sig_Adapter *) *eh; - - // Remove the handler if (1) its key matches the key we've - // been told to remove or (2) if we've been told to remove - // *all* handlers (i.e., == -1). - if (sh->sigkey () == sigkey || sigkey == -1) - { - handler_set->remove (*eh); - delete *eh; - } - } - - if (handler_set->size () == 0) - { - // If there are no more handlers left for a signal then - // register the new disposition or restore the default - // disposition. - ACE_Sig_Action sa (SIG_DFL, (sigset_t *) 0); - - if (new_disp == 0) - new_disp = &sa; - - return new_disp->register_action (signum, old_disp); - } - return 0; - } - else - return -1; -} - -/// Master dispatcher function that gets called by a signal handler and -/// dispatches *all* the handlers... -void -ACE_Sig_Handlers::dispatch (int signum, - siginfo_t *siginfo, - ucontext_t *ucontext) -{ - ACE_TRACE ("ACE_Sig_Handlers::dispatch"); - // The following is #ifdef'd out because it's entirely non-portable - // to acquire a mutex in a signal handler... -#if 0 - ACE_MT (ACE_Recursive_Thread_Mutex *lock = - ACE_Managed_Object::get_preallocated_object - (ACE_Object_Manager::ACE_SIG_HANDLER_LOCK); - ACE_TSS_Guard m (*lock)); -#endif /* 0 */ - - // Save/restore errno. - ACE_Errno_Guard error (errno); - - ACE_Sig_Handler::sig_pending_ = 1; - - // Darn well better be in range since the OS dispatched this... - ACE_ASSERT (ACE_Sig_Handler::in_range (signum)); - - ACE_SIG_HANDLERS_SET *handler_set = - ACE_Sig_Handlers_Set::instance (signum); - - ACE_SIG_HANDLERS_ITERATOR handler_iterator (*handler_set); - - for (ACE_Event_Handler **eh = 0; - handler_iterator.next (eh) != 0; - ) - if ((*eh)->handle_signal (signum, siginfo, ucontext) == -1) - { - handler_set->remove (*eh); - delete *eh; - } -} - -/// Return the first item in the list of handlers. Note that this will -/// trivially provide the same behavior as the ACE_Sig_Handler -/// version if there is only 1 handler registered! -ACE_Event_Handler * -ACE_Sig_Handlers::handler (int signum) -{ - ACE_TRACE ("ACE_Sig_Handlers::handler"); - ACE_SIG_HANDLERS_SET *handler_set = - ACE_Sig_Handlers_Set::instance (signum); - ACE_SIG_HANDLERS_ITERATOR handler_iterator (*handler_set); - ACE_Event_Handler **eh = 0; - handler_iterator.next (eh); - return *eh; -} - -/// The following is a strange bit of logic that tries to give the same -/// semantics as what happens in ACE_Sig_Handler when we replace the -/// current signal handler with a new one. Note that if there is only -/// one signal handler the behavior will be identical. If there is -/// more than one handler then things get weird... -ACE_Event_Handler * -ACE_Sig_Handlers::handler (int signum, ACE_Event_Handler *new_sh) -{ - ACE_TRACE ("ACE_Sig_Handlers::handler"); - ACE_SIG_HANDLERS_SET *handler_set = - ACE_Sig_Handlers_Set::instance (signum); - ACE_SIG_HANDLERS_ITERATOR handler_iterator (*handler_set); - ACE_Event_Handler **eh = 0; - - // Find the first handler... - handler_iterator.next (eh); - - // ... then remove it from the set ... - handler_set->remove (*eh); - - // ... and then insert the new signal handler into the beginning of - // the set (note, this is a bit too tied up in the implementation of - // ACE_Unbounded_Set...). - ACE_Sig_Adapter *temp = 0; - - ACE_NEW_RETURN (temp, - ACE_Sig_Adapter (new_sh, - ++ACE_Sig_Handlers::sigkey_), - 0); - handler_set->insert (temp); - return *eh; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Sig_Handler.h b/deps/acelite/ace/Sig_Handler.h deleted file mode 100644 index 1bd2a66d4..000000000 --- a/deps/acelite/ace/Sig_Handler.h +++ /dev/null @@ -1,243 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Sig_Handler.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_SIGNAL_HANDLER_H -#define ACE_SIGNAL_HANDLER_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Event_Handler.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Sig_Action; - -/** - * @class ACE_Sig_Handler - * - * @brief This is the main dispatcher of signals for ACE. It improves - * the existing UNIX signal handling mechanism by allowing C++ - * objects to handle signals in a way that avoids the use of - * global/static variables and functions. - * - * Using this class a program can register an ACE_Event_Handler - * with the ACE_Sig_Handler in order to handle a designated - * @a signum. When a signal occurs that corresponds to this - * @a signum, the @c handle_signal method of the registered - * ACE_Event_Handler is invoked automatically. - */ -class ACE_Export ACE_Sig_Handler -{ -public: - /// Default constructor. - ACE_Sig_Handler (void); - - /// Destructor - virtual ~ACE_Sig_Handler (void); - - // = Registration and removal methods. - /** - * Add a new ACE_Event_Handler and a new sigaction associated with - * @a signum. Passes back the existing ACE_Event_Handler and its - * sigaction if pointers are non-zero. Returns -1 on failure and >= - * 0 on success. - */ - virtual int register_handler (int signum, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp = 0, - ACE_Event_Handler **old_sh = 0, - ACE_Sig_Action *old_disp = 0); - - /** - * Remove the ACE_Event_Handler currently associated with - * @a signum. @a sigkey is ignored in this implementation since there - * is only one instance of a signal handler. Install the new - * disposition (if given) and return the previous disposition (if - * desired by the caller). Returns 0 on success and -1 if @a signum - * is invalid. - */ - virtual int remove_handler (int signum, - ACE_Sig_Action *new_disp = 0, - ACE_Sig_Action *old_disp = 0, - int sigkey = -1); - - // Set/get signal status. - /// True if there is a pending signal. - static int sig_pending (void); - - /// Reset the value of so that no signal is pending. - static void sig_pending (int); - - // = Set/get the handler associated with a particular signal. - - /// Return the ACE_Sig_Handler associated with @a signum. - virtual ACE_Event_Handler *handler (int signum); - - /// Set a new ACE_Event_Handler that is associated with @a signum. - /// Return the existing handler. - virtual ACE_Event_Handler *handler (int signum, ACE_Event_Handler *); - - /** - * Callback routine registered with sigaction(2) that dispatches the - * method of the appropriate pre-registered - * ACE_Event_Handler. - */ - static void dispatch (int, siginfo_t *, - ucontext_t *); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - // = These methods and data members are shared by derived classes. - - /** - * Set a new ACE_Event_Handler that is associated with @a signum. - * Return the existing handler. Does not acquire any locks so that - * it can be called from a signal handler, such as . - */ - static ACE_Event_Handler *handler_i (int signum, - ACE_Event_Handler *); - - /** - * This implementation method is called by and - * @c dispatch. It doesn't do any locking so that it can be called - * within a signal handler, such as @c dispatch. It adds a new - * ACE_Event_Handler and a new sigaction associated with @a signum. - * Passes back the existing ACE_Event_Handler and its sigaction if - * pointers are non-zero. Returns -1 on failure and >= 0 on - * success. - */ - static int register_handler_i (int signum, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp = 0, - ACE_Event_Handler **old_sh = 0, - ACE_Sig_Action *old_disp = 0); - - static int remove_handler_i (int signum, - ACE_Sig_Action *new_disp = 0, - ACE_Sig_Action *old_disp = 0, - int sigkey = -1); - - /// Check whether the SIGNUM is within the legal range of signals. - static int in_range (int signum); - - /// Keeps track of whether a signal is pending. - static sig_atomic_t sig_pending_; - -private: - /// Array used to store one user-defined Event_Handler for every - /// signal. - static ACE_Event_Handler *signal_handlers_[ACE_NSIG]; -}; - -/** - * @class ACE_Sig_Handlers - * - * @brief This is an alternative signal handling dispatcher for ACE. It - * allows a list of signal handlers to be registered for each - * signal. It also makes SA_RESTART the default mode. - * - * Using this class a program can register one or more - * ACE_Event_Handler with the ACE_Sig_Handler in order to - * handle a designated @a signum. When a signal occurs that - * corresponds to this @a signum, the methods of - * all the registered ACE_Event_Handlers are invoked - * automatically. - */ -class ACE_Export ACE_Sig_Handlers : public ACE_Sig_Handler -{ -public: - /// Default constructor - ACE_Sig_Handlers (void); - - // = Registration and removal methods. - /** - * Add a new ACE_Event_Handler and a new sigaction associated with - * @a signum. Passes back the existing ACE_Event_Handler and its - * sigaction if pointers are non-zero. Returns -1 on failure and - * a that is >= 0 on success. - */ - virtual int register_handler (int signum, - ACE_Event_Handler *new_sh, - ACE_Sig_Action *new_disp = 0, - ACE_Event_Handler **old_sh = 0, - ACE_Sig_Action *old_disp = 0); - - /** - * Remove an ACE_Event_Handler currently associated with @a signum. - * We remove the handler if (1) its sigkey> matches the @a sigkey - * passed as a parameter or (2) if we've been told to remove all the - * handlers, i.e., @a sigkey == -1. If a new disposition is given it - * is installed and the previous disposition is returned (if desired - * by the caller). Returns 0 on success and -1 if @a signum is - * invalid. - */ - virtual int remove_handler (int signum, - ACE_Sig_Action *new_disp = 0, - ACE_Sig_Action *old_disp = 0, - int sigkey = -1); - - // = Set/get the handler associated with a particular signal. - - /// Return the head of the list of ACE_Sig_Handlers associated with - /// SIGNUM. - virtual ACE_Event_Handler *handler (int signum); - - /** - * Set a new ACE_Event_Handler that is associated with SIGNUM at - * the head of the list of signals. Return the existing handler - * that was at the head. - */ - virtual ACE_Event_Handler *handler (int signum, - ACE_Event_Handler *); - - /** - * Callback routine registered with sigaction(2) that dispatches the - * handle_signal() method of all the pre-registered - * ACE_Event_Handlers for @a signum - */ - static void dispatch (int signum, siginfo_t *, ucontext_t *); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /** - * Keeps track of the id that uniquely identifies each registered - * signal handler. This id can be used to cancel a timer via the - * method. - */ - static int sigkey_; - - /// If this is true then a 3rd party library has registered a - /// handler... - static bool third_party_sig_handler_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Sig_Handler.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_SIG_HANDLER_H */ diff --git a/deps/acelite/ace/Sig_Handler.inl b/deps/acelite/ace/Sig_Handler.inl deleted file mode 100644 index a2ad69de7..000000000 --- a/deps/acelite/ace/Sig_Handler.inl +++ /dev/null @@ -1,12 +0,0 @@ -// -*- C++ -*- -ACE_INLINE -ACE_Sig_Handler::ACE_Sig_Handler (void) -{ -} - -ACE_INLINE int -ACE_Sig_Handler::in_range (int signum) -{ - ACE_TRACE ("ACE_Sig_Handler::in_range"); - return signum > 0 && signum < ACE_NSIG; -} diff --git a/deps/acelite/ace/Signal.cpp b/deps/acelite/ace/Signal.cpp deleted file mode 100644 index b04b80042..000000000 --- a/deps/acelite/ace/Signal.cpp +++ /dev/null @@ -1,223 +0,0 @@ -#include "ace/Signal.h" -// #include "ace/Log_Category.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/Signal.inl" -#endif /* __ACE_INLINE__ */ - - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Sig_Action) - -void -ACE_Sig_Action::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Sig_Action::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Sig_Set) - -ACE_Sig_Set::~ACE_Sig_Set (void) -{ - ACE_TRACE ("ACE_Sig_Set::~ACE_Sig_Set"); - ACE_OS::sigemptyset (&this->sigset_); -} - -ACE_Sig_Action::~ACE_Sig_Action (void) -{ - ACE_TRACE ("ACE_Sig_Action::~ACE_Sig_Action"); -} - -// Restore the signal mask. - -ACE_Sig_Guard::~ACE_Sig_Guard (void) -{ - //ACE_TRACE ("ACE_Sig_Guard::~ACE_Sig_Guard"); - if (!this->condition_) - return; - -#if !defined (ACE_LACKS_UNIX_SIGNALS) -#if defined (ACE_LACKS_PTHREAD_THR_SIGSETMASK) - ACE_OS::sigprocmask (SIG_SETMASK, - (sigset_t *) this->omask_, - 0); -#else - ACE_OS::thr_sigsetmask (SIG_SETMASK, - (sigset_t *) this->omask_, - 0); -#endif /* ACE_LACKS_PTHREAD_THR_SIGSETMASK */ -#endif /* !ACE_LACKS_UNIX_SIGNALS */ -} - -void -ACE_Sig_Set::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Sig_Set::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Sig_Guard) - -void -ACE_Sig_Guard::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Sig_Guard::dump"); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Sig_Action::ACE_Sig_Action (void) -{ - // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action"); - this->sa_.sa_flags = 0; - - // Since Service_Config::signal_handler_ is static and has an - // ACE_Sig_Action instance, Win32 will get errno set unless this is - // commented out. -#if !defined (ACE_WIN32) - ACE_OS::sigemptyset (&this->sa_.sa_mask); -#endif /* ACE_WIN32 */ - this->sa_.sa_handler = 0; -} - -ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler, - sigset_t *sig_mask, - int sig_flags) -{ - // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action"); - this->sa_.sa_flags = sig_flags; - - if (sig_mask == 0) - ACE_OS::sigemptyset (&this->sa_.sa_mask); - else - this->sa_.sa_mask = *sig_mask; // Structure assignment... - -#if !defined(ACE_HAS_TANDEM_SIGNALS) - this->sa_.sa_handler = ACE_SignalHandlerV (sig_handler); -#else - this->sa_.sa_handler = (void (*)()) ACE_SignalHandlerV (sig_handler); -#endif /* !ACE_HAS_TANDEM_SIGNALS */ -} - -ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler, - const ACE_Sig_Set &sig_mask, - int sig_flags) -{ - // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action"); - this->sa_.sa_flags = sig_flags; - - // Structure assignment... - this->sa_.sa_mask = sig_mask.sigset (); - -#if !defined(ACE_HAS_TANDEM_SIGNALS) - this->sa_.sa_handler = ACE_SignalHandlerV (sig_handler); -#else - this->sa_.sa_handler = (void (*)()) ACE_SignalHandlerV (sig_handler); -#endif /* !ACE_HAS_TANDEM_SIGNALS */ -} - -ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler, - int signum, - sigset_t *sig_mask, - int sig_flags) -{ - // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action"); - this->sa_.sa_flags = sig_flags; - - if (sig_mask == 0) - ACE_OS::sigemptyset (&this->sa_.sa_mask); - else - this->sa_.sa_mask = *sig_mask; // Structure assignment... - -#if !defined(ACE_HAS_TANDEM_SIGNALS) - this->sa_.sa_handler = ACE_SignalHandlerV (sig_handler); -#else - this->sa_.sa_handler = (void (*)()) ACE_SignalHandlerV (sig_handler); -#endif /* !ACE_HAS_TANDEM_SIGNALS */ - ACE_OS::sigaction (signum, &this->sa_, 0); -} - -ACE_Sig_Action::ACE_Sig_Action (ACE_SignalHandler sig_handler, - int signum, - const ACE_Sig_Set &sig_mask, - int sig_flags) -{ - // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action"); - this->sa_.sa_flags = sig_flags; - - // Structure assignment... - this->sa_.sa_mask = sig_mask.sigset (); - -#if !defined(ACE_HAS_TANDEM_SIGNALS) - this->sa_.sa_handler = ACE_SignalHandlerV (sig_handler); -#else - this->sa_.sa_handler = (void (*)()) ACE_SignalHandlerV (sig_handler); -#endif /* !ACE_HAS_TANDEM_SIGNALS */ - ACE_OS::sigaction (signum, &this->sa_, 0); -} - -ACE_Sig_Action::ACE_Sig_Action (const ACE_Sig_Set &signals, - ACE_SignalHandler sig_handler, - const ACE_Sig_Set &sig_mask, - int sig_flags) -{ - // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action"); - this->sa_.sa_flags = sig_flags; - - // Structure assignment... - this->sa_.sa_mask = sig_mask.sigset (); - -#if !defined(ACE_HAS_TANDEM_SIGNALS) - this->sa_.sa_handler = ACE_SignalHandlerV (sig_handler); -#else - this->sa_.sa_handler = (void (*)()) ACE_SignalHandlerV (sig_handler); -#endif /* !ACE_HAS_TANDEM_SIGNALS */ - -#if (ACE_NSIG > 0) - for (int s = 1; s < ACE_NSIG; s++) - if ((signals.is_member (s)) == 1) - ACE_OS::sigaction (s, &this->sa_, 0); -#else /* ACE_NSIG <= 0 */ - ACE_UNUSED_ARG (signals); -#endif /* ACE_NSIG <= 0 */ -} - -ACE_Sig_Action::ACE_Sig_Action (const ACE_Sig_Set &signals, - ACE_SignalHandler sig_handler, - sigset_t *sig_mask, - int sig_flags) -{ - // ACE_TRACE ("ACE_Sig_Action::ACE_Sig_Action"); - this->sa_.sa_flags = sig_flags; - - if (sig_mask == 0) - ACE_OS::sigemptyset (&this->sa_.sa_mask); - else - this->sa_.sa_mask = *sig_mask; // Structure assignment... - -#if !defined(ACE_HAS_TANDEM_SIGNALS) - this->sa_.sa_handler = ACE_SignalHandlerV (sig_handler); -#else - this->sa_.sa_handler = (void (*)()) ACE_SignalHandlerV (sig_handler); -#endif /* !ACE_HAS_TANDEM_SIGNALS */ - -#if (ACE_NSIG > 0) - for (int s = 1; s < ACE_NSIG; s++) - if ((signals.is_member (s)) == 1) - ACE_OS::sigaction (s, &this->sa_, 0); -#else /* ACE_NSIG <= 0 */ - ACE_UNUSED_ARG (signals); -#endif /* ACE_NSIG <= 0 */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Signal.h b/deps/acelite/ace/Signal.h deleted file mode 100644 index 416722eb8..000000000 --- a/deps/acelite/ace/Signal.h +++ /dev/null @@ -1,254 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Signal.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_SIGNAL_H -#define ACE_SIGNAL_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-lite.h" - -#if defined (ACE_DONT_INCLUDE_ACE_SIGNAL_H) -# error ace/Signal.h was #included instead of signal.h by ace/OS_NS_signal.h: fix!!!! -#endif /* ACE_DONT_INCLUDE_ACE_SIGNAL_H */ - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/OS_NS_signal.h" - -/// Type of the extended signal handler. -typedef void (*ACE_Sig_Handler_Ex) (int, siginfo_t *siginfo, ucontext_t *ucontext); - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Sig_Set - * - * @brief Provide a C++ wrapper for the C sigset_t interface. - * - * Handle signals via a more elegant C++ interface (e.g., - * doesn't require the use of global variables or global - * functions in an application). - */ -class ACE_Export ACE_Sig_Set -{ -public: - /// Initialize with @a sigset. If @a sigset == 0 then fill - /// the set. - ACE_Sig_Set (sigset_t *sigset); - - /// Initialize with @a sigset. If @a sigset == 0 then fill - /// the set. - ACE_Sig_Set (ACE_Sig_Set *sigset); - - /// If @a fill == 0 then initialize the to be empty, else - /// full. - ACE_Sig_Set (int fill = 0); - - ~ACE_Sig_Set (void); - - /// Create a set that excludes all signals defined by the system. - int empty_set (void); - - /// Create a set that includes all signals defined by the system. - int fill_set (void); - - /// Adds the individual signal specified by @a signo to the set. - int sig_add (int signo); - - /// Deletes the individual signal specified by @a signo from the set. - int sig_del (int signo); - - /// Checks whether the signal specified by @a signo is in the set. - int is_member (int signo) const; - - /// Returns a pointer to the underlying @c sigset_t. - operator sigset_t *(); - - /// Returns a copy of the underlying @c sigset_t. - sigset_t sigset (void) const; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Set of signals. - sigset_t sigset_; -}; - -/** - * @class ACE_Sig_Action - * - * @brief C++ wrapper facade for the @c sigaction struct. - */ -class ACE_Export ACE_Sig_Action -{ -public: - /// Default constructor. Initializes everything to 0. - ACE_Sig_Action (void); - - /// Assigns the various fields of a @c sigaction struct but doesn't - /// register for signal handling via the @c sigaction function. - ACE_Sig_Action (ACE_SignalHandler handler, - sigset_t *sigmask = 0, - int flags = 0); - - /// Assigns the various fields of a @c sigaction struct but doesn't - /// register for signal handling via the @c sigaction function. - ACE_Sig_Action (ACE_SignalHandler handler, - const ACE_Sig_Set &sigmask, - int flags = 0); - - /** - * Assigns the various fields of a @c sigaction struct and registers - * the @a handler to process signal @a signum via the @c sigaction - * function. - */ - ACE_Sig_Action (ACE_SignalHandler handler, - int signum, - sigset_t *sigmask = 0, - int flags = 0); - - /** - * Assigns the various fields of a @c sigaction struct and registers - * the @a handler to process signal @a signum via the @c sigaction - * function. - */ - ACE_Sig_Action (ACE_SignalHandler handler, - int signum, - const ACE_Sig_Set &sigmask, - int flags = 0); - - /** - * Assigns the various fields of a @c sigaction struct and registers - * the @a handler to process all @a signalss via the @c sigaction - * function. - */ - ACE_Sig_Action (const ACE_Sig_Set &signalss, - ACE_SignalHandler handler, - const ACE_Sig_Set &sigmask, - int flags = 0); - - /** - * Assigns the various fields of a @c sigaction struct and registers - * the @a handler to process all @a signalss via the @c sigaction - * function. - */ - ACE_Sig_Action (const ACE_Sig_Set &signalss, - ACE_SignalHandler handler, - sigset_t *sigmask = 0, - int flags = 0); - -#if defined (ACE_HAS_CPP11) - ACE_Sig_Action (const ACE_Sig_Action&) = default; - ACE_Sig_Action (ACE_Sig_Action&&) = default; - ACE_Sig_Action& operator = (ACE_Sig_Action const &) = default; - ACE_Sig_Action &operator = (ACE_Sig_Action&&) = default; -#endif /* ACE_HAS_CPP11 */ - - /// Default dtor. - ~ACE_Sig_Action (void); - - // = Signal action management. - /// Register @c this as the current disposition and store old - /// disposition into @a oaction if it is non-NULL. - int register_action (int signum, - ACE_Sig_Action *oaction = 0); - - /// Assign the value of @a oaction to @c this and make it become the - /// new signal disposition. - int restore_action (int signum, - ACE_Sig_Action &oaction); - - /// Retrieve the current disposition into @c this. - int retrieve_action (int signum); - - /// Set current signal action. - void set (struct sigaction *); - - /// Get current signal action. - struct sigaction *get (void); - operator struct sigaction *(); - - /// Set current signal flags. - void flags (int); - - /// Get current signal flags. - int flags (void); - - /// Set current signal mask. - void mask (sigset_t *); - void mask (ACE_Sig_Set &); - - /// Get current signal mask. - sigset_t *mask (void); - - /// Set current signal handler (pointer to function). - void handler (ACE_SignalHandler); - - /// Get current signal handler (pointer to function). - ACE_SignalHandler handler (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Controls signal behavior. - struct sigaction sa_; -}; - -/** - * @class ACE_Sig_Guard - * - * @brief Hold signals in MASK for duration of a C++ statement block. - * Note that a "0" for mask causes all signals to be held. - */ -class ACE_Export ACE_Sig_Guard -{ -public: - /// This is kind of conditional Guard, needed when guard should be - /// activated only when a specific condition met. When condition == - /// true (default), Guard is activated - ACE_Sig_Guard (ACE_Sig_Set *mask = 0, bool condition = true); - - /// Restore blocked signals. - ~ACE_Sig_Guard (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Original signal mask. - ACE_Sig_Set omask_; - - /// Guard Condition - bool condition_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Signal.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_SIGNAL_HANDLER_H */ diff --git a/deps/acelite/ace/Signal.inl b/deps/acelite/ace/Signal.inl deleted file mode 100644 index 64ac6c049..000000000 --- a/deps/acelite/ace/Signal.inl +++ /dev/null @@ -1,238 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_signal.h" -#include "ace/config-all.h" -#include "ace/Trace.h" -#include "ace/Object_Manager_Base.h" -#include "ace/OS_NS_Thread.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Sig_Set::ACE_Sig_Set (sigset_t *ss) - // : sigset_ () -{ - ACE_TRACE ("ACE_Sig_Set::ACE_Sig_Set"); - - if (ss == 0) - ACE_OS::sigfillset (&this->sigset_); - else - // Structure assignment. - this->sigset_ = *ss; -} - -ACE_INLINE -ACE_Sig_Set::ACE_Sig_Set (int fill) - // : sigset_ () -{ - ACE_TRACE ("ACE_Sig_Set::ACE_Sig_Set"); - - if (fill) - ACE_OS::sigfillset (&this->sigset_); - else - ACE_OS::sigemptyset (&this->sigset_); -} - -ACE_INLINE -ACE_Sig_Set::ACE_Sig_Set (ACE_Sig_Set *ss) - // : sigset_ () -{ - ACE_TRACE ("ACE_Sig_Set::ACE_Sig_Set"); - - if (ss == 0) - ACE_OS::sigfillset (&this->sigset_); - else - this->sigset_ = ss->sigset_; -} - -ACE_INLINE int -ACE_Sig_Set::empty_set (void) -{ - ACE_TRACE ("ACE_Sig_Set::empty_set"); - return ACE_OS::sigemptyset (&this->sigset_); -} - -ACE_INLINE int -ACE_Sig_Set::fill_set (void) -{ - ACE_TRACE ("ACE_Sig_Set::fill_set"); - return ACE_OS::sigfillset (&this->sigset_); -} - -ACE_INLINE int -ACE_Sig_Set::sig_add (int signo) -{ - ACE_TRACE ("ACE_Sig_Set::sig_add"); - return ACE_OS::sigaddset (&this->sigset_, signo); -} - -ACE_INLINE int -ACE_Sig_Set::sig_del (int signo) -{ - ACE_TRACE ("ACE_Sig_Set::sig_del"); - return ACE_OS::sigdelset (&this->sigset_, signo); -} - -ACE_INLINE int -ACE_Sig_Set::is_member (int signo) const -{ - ACE_TRACE ("ACE_Sig_Set::is_member"); - return ACE_OS::sigismember (const_cast (&this->sigset_), signo); -} - -ACE_INLINE -ACE_Sig_Set::operator sigset_t *(void) -{ - ACE_TRACE ("ACE_Sig_Set::operator sigset_t *"); - return &this->sigset_; -} - -ACE_INLINE sigset_t -ACE_Sig_Set::sigset (void) const -{ - ACE_TRACE ("ACE_Sig_Set::sigset"); - return this->sigset_; -} - -ACE_INLINE int -ACE_Sig_Action::flags (void) -{ - ACE_TRACE ("ACE_Sig_Action::flags"); - return this->sa_.sa_flags; -} - -ACE_INLINE void -ACE_Sig_Action::flags (int flags) -{ - ACE_TRACE ("ACE_Sig_Action::flags"); - this->sa_.sa_flags = flags; -} - -ACE_INLINE sigset_t * -ACE_Sig_Action::mask (void) -{ - ACE_TRACE ("ACE_Sig_Action::mask"); - return &this->sa_.sa_mask; -} - -ACE_INLINE void -ACE_Sig_Action::mask (sigset_t *ss) -{ - ACE_TRACE ("ACE_Sig_Action::mask"); - if (ss != 0) - this->sa_.sa_mask = *ss; // Structure assignment -} - -ACE_INLINE void -ACE_Sig_Action::mask (ACE_Sig_Set &ss) -{ - ACE_TRACE ("ACE_Sig_Action::mask"); - this->sa_.sa_mask = ss.sigset (); // Structure assignment -} - -ACE_INLINE ACE_SignalHandler -ACE_Sig_Action::handler (void) -{ - ACE_TRACE ("ACE_Sig_Action::handler"); - return ACE_SignalHandler (this->sa_.sa_handler); -} - -ACE_INLINE void -ACE_Sig_Action::handler (ACE_SignalHandler handler) -{ - ACE_TRACE ("ACE_Sig_Action::handler"); -#if !defined(ACE_HAS_TANDEM_SIGNALS) - this->sa_.sa_handler = ACE_SignalHandlerV (handler); -#else - this->sa_.sa_handler = (void (*)()) ACE_SignalHandlerV (handler); -#endif /* !ACE_HAS_TANDEM_SIGNALS */ -} - -ACE_INLINE void -ACE_Sig_Action::set (struct sigaction *sa) -{ - ACE_TRACE ("ACE_Sig_Action::set"); - this->sa_ = *sa; // Structure assignment. -} - -ACE_INLINE struct sigaction * -ACE_Sig_Action::get (void) -{ - ACE_TRACE ("ACE_Sig_Action::get"); - return &this->sa_; -} - -ACE_INLINE -ACE_Sig_Action::operator struct sigaction * () -{ - ACE_TRACE ("ACE_Sig_Action::operator struct sigaction *"); - return &this->sa_; -} - -ACE_INLINE int -ACE_Sig_Action::register_action (int signum, ACE_Sig_Action *oaction) -{ - ACE_TRACE ("ACE_Sig_Action::register_action"); - struct sigaction *sa = oaction == 0 ? 0 : oaction->get (); - - return ACE_OS::sigaction (signum, &this->sa_, sa); -} - -ACE_INLINE int -ACE_Sig_Action::retrieve_action (int signum) -{ - ACE_TRACE ("ACE_Sig_Action::retrieve_action"); - return ACE_OS::sigaction (signum, 0, &this->sa_); -} - -ACE_INLINE int -ACE_Sig_Action::restore_action (int signum, ACE_Sig_Action &oaction) -{ - ACE_TRACE ("ACE_Sig_Action::restore_action"); - this->sa_ = *oaction.get (); // Structure assignment - return ACE_OS::sigaction (signum, &this->sa_, 0); -} - -// Block out the signal MASK until the destructor is called. - -ACE_INLINE -ACE_Sig_Guard::ACE_Sig_Guard (ACE_Sig_Set *mask, - bool condition) - : omask_ () - , condition_ (condition) -{ - //ACE_TRACE ("ACE_Sig_Guard::ACE_Sig_Guard"); - if (!this->condition_) - return; - -#if defined (ACE_LACKS_UNIX_SIGNALS) - ACE_UNUSED_ARG (mask); -#else - // If MASK is 0 then block all signals! - if (mask == 0) - { -# if defined (ACE_LACKS_PTHREAD_THR_SIGSETMASK) - ACE_OS::sigprocmask (SIG_BLOCK, - ACE_OS_Object_Manager::default_mask (), - (sigset_t *) this->omask_); -# else - ACE_OS::thr_sigsetmask (SIG_BLOCK, - ACE_OS_Object_Manager::default_mask (), - (sigset_t *) this->omask_); -# endif /* ACE_LACKS_PTHREAD_THR_SIGSETMASK */ - } - else -# if defined (ACE_LACKS_PTHREAD_THR_SIGSETMASK) - ACE_OS::sigprocmask (SIG_BLOCK, - (sigset_t *) *mask, - (sigset_t *) - this->omask_); -# else - ACE_OS::thr_sigsetmask (SIG_BLOCK, - (sigset_t *) *mask, - (sigset_t *) - this->omask_); -# endif /* ACE_LACKS_PTHREAD_THR_SIGSETMASK */ -#endif /* ACE_LACKS_UNIX_SIGNALS */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Singleton.cpp b/deps/acelite/ace/Singleton.cpp deleted file mode 100644 index 52ca2b53d..000000000 --- a/deps/acelite/ace/Singleton.cpp +++ /dev/null @@ -1,587 +0,0 @@ -#ifndef ACE_SINGLETON_CPP -#define ACE_SINGLETON_CPP - -#include "ace/Singleton.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (__ACE_INLINE__) -#include "ace/Singleton.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Object_Manager.h" -#include "ace/Log_Category.h" -#include "ace/Framework_Component.h" -#include "ace/Guard_T.h" -#include "ace/os_include/os_typeinfo.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Singleton) -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Unmanaged_Singleton) -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_TSS_Singleton) -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_Unmanaged_TSS_Singleton) -ACE_ALLOC_HOOK_DEFINE_Tcc(ACE_DLL_Singleton_T) -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_DLL_Singleton_Adapter_T) - -template void -ACE_Singleton::dump (void) -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Singleton::dump"); - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("instance_ = %x"), - ACE_Singleton::instance_i ())); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ -#endif /* ACE_HAS_DUMP */ -} - -template ACE_Singleton *& -ACE_Singleton::instance_i (void) -{ -#if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - // Pointer to the Singleton instance. This works around a bug with - // G++ and it's (mis-)handling of templates and statics... - static ACE_Singleton *singleton_ = 0; - - return singleton_; -#else - return ACE_Singleton::singleton_; -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ -} - -template TYPE * -ACE_Singleton::instance (void) -{ - ACE_TRACE ("ACE_Singleton::instance"); - - ACE_Singleton *&singleton = - ACE_Singleton::instance_i (); - - // Perform the Double-Check pattern... - if (singleton == 0) - { - if (ACE_Object_Manager::starting_up () || - ACE_Object_Manager::shutting_down ()) - { - // The program is still starting up, and therefore assumed - // to be single threaded. There's no need to double-check. - // Or, the ACE_Object_Manager instance has been destroyed, - // so the preallocated lock is not available. Either way, - // don't register for destruction with the - // ACE_Object_Manager: we'll have to leak this instance. - - ACE_NEW_RETURN (singleton, (ACE_Singleton), 0); - } - else - { -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - // Obtain a lock from the ACE_Object_Manager. The pointer - // is static, so we only obtain one per ACE_Singleton - // instantiation. -#if defined(ACE_FACE_SAFETY_BASE) - static ACE_LOCK the_lock; - static ACE_LOCK *lock = &the_lock; -#else /* ACE_FACE_SAFETY_BASE */ - static ACE_LOCK *lock = 0; -#endif /* ACE_FACE_SAFETY_BASE */ - if (ACE_Object_Manager::get_singleton_lock (lock) != 0) - // Failed to acquire the lock! - return 0; - - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0); - - if (singleton == 0) - { -#endif /* ACE_MT_SAFE */ - ACE_NEW_RETURN (singleton, (ACE_Singleton), 0); - - // Register for destruction with ACE_Object_Manager. -#if !defined (ACE_MT_SAFE) || (ACE_MT_SAFE == 0) - ACE_Object_Manager::at_exit (singleton, 0, typeid (TYPE).name ()); -#else - ACE_Object_Manager::at_exit (singleton, &lock, - typeid (TYPE).name ()); - } -#endif /* ACE_MT_SAFE */ - } - } - - return &singleton->instance_; -} - -template void -ACE_Singleton::cleanup (void *param) -{ - ACE_Object_Manager::remove_at_exit (this); - delete this; - ACE_Singleton::instance_i () = 0; - -#if !defined ACE_MT_SAFE || ACE_MT_SAFE == 0 || defined ACE_FACE_SAFETY_BASE - ACE_UNUSED_ARG (param); -#else - if (param) - { - ACE_LOCK **lock = static_cast (param); - *lock = 0; - } -#endif -} - -template void -ACE_Singleton::close (void) -{ - ACE_Singleton *&singleton = - ACE_Singleton::instance_i (); - - if (singleton) - { - singleton->cleanup (); - ACE_Singleton::instance_i () = 0; - } -} - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) -// Pointer to the Singleton instance. -template ACE_Singleton * -ACE_Singleton::singleton_ = 0; - -template ACE_Unmanaged_Singleton * -ACE_Unmanaged_Singleton::singleton_ = 0; -#endif /* !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) */ - -template void -ACE_Unmanaged_Singleton::dump (void) -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Unmanaged_Singleton::dump"); - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("instance_ = %x"), - ACE_Unmanaged_Singleton::instance_i ())); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Unmanaged_Singleton *& -ACE_Unmanaged_Singleton::instance_i (void) -{ -#if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - // Pointer to the Singleton instance. This works around a bug with - // G++ and it's (mis-)handling of templates and statics... - static ACE_Unmanaged_Singleton *singleton_ = 0; - - return singleton_; -#else - return ACE_Unmanaged_Singleton::singleton_; -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ -} - -template TYPE * -ACE_Unmanaged_Singleton::instance (void) -{ - ACE_TRACE ("ACE_Unmanaged_Singleton::instance"); - - ACE_Unmanaged_Singleton *&singleton = - ACE_Unmanaged_Singleton::instance_i (); - - // Perform the Double-Check pattern... - if (singleton == 0) - { - if (ACE_Object_Manager::starting_up () || - ACE_Object_Manager::shutting_down ()) - { - // The program is still starting up, and therefore assumed - // to be single threaded. There's no need to double-check. - // Or, the ACE_Object_Manager instance has been destroyed, - // so the preallocated lock is not available. Either way, - // don't register for destruction with the - // ACE_Object_Manager: we'll have to leak this instance. - - ACE_NEW_RETURN (singleton, (ACE_Unmanaged_Singleton), - 0); - } - else - { -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - // Obtain a lock from the ACE_Object_Manager. The pointer - // is static, so we only obtain one per - // ACE_Unmanaged_Singleton instantiation. -#if defined(ACE_FACE_SAFETY_BASE) - static ACE_LOCK the_lock; - static ACE_LOCK *lock = &the_lock; -#else /* ACE_FACE_SAFETY_BASE */ - static ACE_LOCK *lock = 0; -#endif /* ACE_FACE_SAFETY_BASE */ - if (ACE_Object_Manager::get_singleton_lock (lock) != 0) - // Failed to acquire the lock! - return 0; - - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0); -#endif /* ACE_MT_SAFE */ - - if (singleton == 0) - ACE_NEW_RETURN (singleton, - (ACE_Unmanaged_Singleton), - 0); - } - } - - return &singleton->instance_; -} - -template void -ACE_Unmanaged_Singleton::close (void) -{ - ACE_Unmanaged_Singleton *&singleton = - ACE_Unmanaged_Singleton::instance_i (); - - if (singleton) - { - singleton->cleanup (); - ACE_Unmanaged_Singleton::instance_i () = 0; - } -} - -template void -ACE_TSS_Singleton::dump (void) -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_TSS_Singleton::dump"); - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("instance_ = %x"), - ACE_TSS_Singleton::instance_i ())); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ -#endif /* ACE_HAS_DUMP */ -} - -template ACE_TSS_Singleton *& -ACE_TSS_Singleton::instance_i (void) -{ -#if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - // Pointer to the Singleton instance. This works around a bug with - // G++ and it's (mis-)handling of templates and statics... - static ACE_TSS_Singleton *singleton_ = 0; - - return singleton_; -#else - return ACE_TSS_Singleton::singleton_; -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ -} - -template TYPE * -ACE_TSS_Singleton::instance (void) -{ - ACE_TRACE ("ACE_TSS_Singleton::instance"); - - ACE_TSS_Singleton *&singleton = - ACE_TSS_Singleton::instance_i (); - - // Perform the Double-Check pattern... - if (singleton == 0) - { - if (ACE_Object_Manager::starting_up () || - ACE_Object_Manager::shutting_down ()) - { - // The program is still starting up, and therefore assumed - // to be single threaded. There's no need to double-check. - // Or, the ACE_Object_Manager instance has been destroyed, - // so the preallocated lock is not available. Either way, - // don't register for destruction with the - // ACE_Object_Manager: we'll have to leak this instance. - - ACE_NEW_RETURN (singleton, (ACE_TSS_Singleton), 0); - } - else - { -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - - // Obtain a lock from the ACE_Object_Manager. The pointer - // is static, so we only obtain one per ACE_Singleton instantiation. -#if defined(ACE_FACE_SAFETY_BASE) - static ACE_LOCK the_lock; - static ACE_LOCK *lock = &the_lock; -#else /* ACE_FACE_SAFETY_BASE */ - static ACE_LOCK *lock = 0; -#endif /* ACE_FACE_SAFETY_BASE */ - if (ACE_Object_Manager::get_singleton_lock (lock) != 0) - // Failed to acquire the lock! - return 0; - - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0); - - if (singleton == 0) - { -#endif /* ACE_MT_SAFE */ - ACE_NEW_RETURN (singleton, (ACE_TSS_Singleton), - 0); - - // Register for destruction with ACE_Object_Manager. - ACE_Object_Manager::at_exit (singleton, 0, typeid (TYPE).name ()); -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - } -#endif /* ACE_MT_SAFE */ - } - } - - return ACE_TSS_GET (&singleton->instance_, TYPE); -} - -template void -ACE_TSS_Singleton::cleanup (void *) -{ - delete this; - ACE_TSS_Singleton::instance_i () = 0; -} - -template void -ACE_Unmanaged_TSS_Singleton::dump (void) -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Unmanaged_TSS_Singleton::dump"); - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("instance_ = %x"), - ACE_Unmanaged_TSS_Singleton::instance_i ())); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_Unmanaged_TSS_Singleton *& -ACE_Unmanaged_TSS_Singleton::instance_i (void) -{ -#if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - // Pointer to the Singleton instance. This works around a bug with - // G++ and it's (mis-)handling of templates and statics... - static ACE_Unmanaged_TSS_Singleton *singleton_ = 0; - - return singleton_; -#else - return ACE_Unmanaged_TSS_Singleton::singleton_; -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ -} - -template TYPE * -ACE_Unmanaged_TSS_Singleton::instance (void) -{ - ACE_TRACE ("ACE_Unmanaged_TSS_Singleton::instance"); - - ACE_Unmanaged_TSS_Singleton *&singleton = - ACE_Unmanaged_TSS_Singleton::instance_i (); - - // Perform the Double-Check pattern... - if (singleton == 0) - { - if (ACE_Object_Manager::starting_up () || - ACE_Object_Manager::shutting_down ()) - { - // The program is still starting up, and therefore assumed - // to be single threaded. There's no need to double-check. - // Or, the ACE_Object_Manager instance has been destroyed, - // so the preallocated lock is not available. Either way, - // don't register for destruction with the - // ACE_Object_Manager: we'll have to leak this instance. - - ACE_NEW_RETURN (singleton, - (ACE_Unmanaged_TSS_Singleton), - 0); - } - else - { -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - // Obtain a lock from the ACE_Object_Manager. The pointer - // is static, so we only obtain one per - // ACE_Unmanaged_Singleton instantiation. -#if defined(ACE_FACE_SAFETY_BASE) - static ACE_LOCK the_lock; - static ACE_LOCK *lock = &the_lock; -#else /* ACE_FACE_SAFETY_BASE */ - static ACE_LOCK *lock = 0; -#endif /* ACE_FACE_SAFETY_BASE */ - if (ACE_Object_Manager::get_singleton_lock (lock) != 0) - // Failed to acquire the lock! - return 0; - - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0); -#endif /* ACE_MT_SAFE */ - - if (singleton == 0) - ACE_NEW_RETURN (singleton, - (ACE_Unmanaged_TSS_Singleton), - 0); - } - } - - return ACE_TSS_GET (&singleton->instance_, TYPE); -} - -template void -ACE_Unmanaged_TSS_Singleton::close (void) -{ - ACE_Unmanaged_TSS_Singleton *&singleton = - ACE_Unmanaged_TSS_Singleton::instance_i (); - - if (singleton) - singleton->cleanup (); -} - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) -// Pointer to the Singleton instance. -template ACE_TSS_Singleton * -ACE_TSS_Singleton::singleton_ = 0; - -template -ACE_Unmanaged_TSS_Singleton * -ACE_Unmanaged_TSS_Singleton::singleton_ = 0; -#endif /* !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) */ - -/*************************************************************************/ - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) -// Pointer to the Singleton instance. -template ACE_DLL_Singleton_T * -ACE_DLL_Singleton_T::singleton_ = 0; -#endif /* !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) */ - -template void -ACE_DLL_Singleton_T::dump (void) -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_DLL_Singleton_T::dump"); - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("instance_ = %x"), - ACE_DLL_Singleton_T::instance_i ())); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_DLL_Singleton_T *& -ACE_DLL_Singleton_T::instance_i (void) -{ - ACE_TRACE ("ACE_DLL_Singleton_T::instance_i"); - -#if defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - // Pointer to the Singleton instance. This works around a bug with - // G++ and it's (mis-)handling of templates and statics... - static ACE_DLL_Singleton_T *singleton_ = 0; - - return singleton_; -#else - return ACE_DLL_Singleton_T::singleton_; -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ -} - -template TYPE * -ACE_DLL_Singleton_T::instance (void) -{ - ACE_TRACE ("ACE_DLL_Singleton_T::instance"); - - ACE_DLL_Singleton_T *&singleton = - ACE_DLL_Singleton_T::instance_i (); - - // Perform the Double-Check pattern... - if (singleton == 0) - { - if (ACE_Object_Manager::starting_up () || - ACE_Object_Manager::shutting_down ()) - { - // The program is still starting up, and therefore assumed - // to be single threaded. There's no need to double-check. - // Or, the ACE_Object_Manager instance has been destroyed, - // so the preallocated lock is not available. Either way, - // don't register for destruction with the - // ACE_Object_Manager: we'll have to leak this instance. - - ACE_NEW_RETURN (singleton, (ACE_DLL_Singleton_T), - 0); - } - else - { -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - // Obtain a lock from the ACE_Object_Manager. The pointer - // is static, so we only obtain one per - // ACE_Unmanaged_Singleton instantiation. -#if defined(ACE_FACE_SAFETY_BASE) - static ACE_LOCK the_lock; - static ACE_LOCK *lock = &the_lock; -#else /* ACE_FACE_SAFETY_BASE */ - static ACE_LOCK *lock = 0; -#endif /* ACE_FACE_SAFETY_BASE */ - if (ACE_Object_Manager::get_singleton_lock (lock) != 0) - // Failed to acquire the lock! - return 0; - - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, *lock, 0); -#endif /* ACE_MT_SAFE */ - - if (singleton == 0) - ACE_NEW_RETURN (singleton, - (ACE_DLL_Singleton_T), - 0); - } - //ACE_REGISTER_FRAMEWORK_COMPONENT(ACE_DLL_Singleton, singleton); - ACE_Framework_Repository::instance ()->register_component - (new ACE_Framework_Component_T > (singleton)); - } - - return &singleton->instance_; -} - -template void -ACE_DLL_Singleton_T::close (void) -{ - ACE_TRACE ("ACE_DLL_Singleton_T::close"); - - ACE_DLL_Singleton_T *&singleton = - ACE_DLL_Singleton_T::instance_i (); - - delete singleton; - singleton = 0; -} - -template void -ACE_DLL_Singleton_T::close_singleton (void) -{ - ACE_TRACE ("ACE_DLL_Singleton_T::close_singleton"); - ACE_DLL_Singleton_T::close (); -} - -template const ACE_TCHAR * -ACE_DLL_Singleton_T::dll_name (void) -{ - return this->instance ()->dll_name (); -} - -template const ACE_TCHAR * -ACE_DLL_Singleton_T::name (void) -{ - return this->instance ()->name (); -} - - -/**********************************************************************/ - -template const ACE_TCHAR* -ACE_DLL_Singleton_Adapter_T::dll_name (void) -{ - // @todo make this a constant somewhere (or it there already is one - // then use it. - return ACE_TEXT("ACE"); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_SINGLETON_CPP */ diff --git a/deps/acelite/ace/Singleton.h b/deps/acelite/ace/Singleton.h deleted file mode 100644 index d0cd95f4a..000000000 --- a/deps/acelite/ace/Singleton.h +++ /dev/null @@ -1,346 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Singleton.h - * - * @brief - * - * @author Tim Harrison - * @author Douglas C. Schmidt - * @author Chris Lahey - * @author Rich Christy - * @author David Levine - */ -//============================================================================= - -#ifndef ACE_SINGLETON_H -#define ACE_SINGLETON_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" -#include "ace/TSS_T.h" -#include "ace/Cleanup.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Singleton - * - * @brief A Singleton Adapter uses the Adapter pattern to turn ordinary - * classes into Singletons optimized with the Double-Checked - * Locking optimization pattern. - * - * This implementation is a slight variation on the GoF - * Singleton pattern. In particular, a single - * > instance is allocated here, - * not a instance. The reason for this is to allow - * registration with the ACE_Object_Manager, so that the - * Singleton can be cleaned up when the process exits. For this - * scheme to work, a (static) cleanup() function must be - * provided. ACE_Singleton provides one so that TYPE doesn't - * need to. - * If you want to make sure that only the singleton instance of - * is created, and that users cannot create their own - * instances of , do the following to class : - * (a) Make the constructor of private (or protected) - * (b) Make Singleton a friend of - * Here is an example: - * @verbatim - * class foo - * { - * friend class ACE_Singleton; - * private: - * foo () { cout << "foo constructed" << endl; } - * ~foo () { cout << "foo destroyed" << endl; } - * }; - * typedef ACE_Singleton FOO; - * @endverbatim - * - * @note The best types to use for ACE_LOCK are - * ACE_Recursive_Thread_Mutex and ACE_Null_Mutex. - * ACE_Recursive_Thread_Mutex should be used in multi-threaded - * programs in which it is possible for more than one thread to - * access the > instance. - * ACE_Null_Mutex can be used otherwise. The reason that these - * types of locks are best has to do with their allocation by - * the ACE_Object_Manager. Single ACE_Recursive_Thread_Mutex - * and ACE_Null_Mutex instances are used for all ACE_Singleton - * instantiations. However, other types of locks are allocated - * per ACE_Singleton instantiation. - */ -template -class ACE_Singleton : public ACE_Cleanup -{ -public: - /// Global access point to the Singleton. - static TYPE *instance (void); - - /// Cleanup method, used by @c ace_cleanup_destroyer to destroy the - /// ACE_Singleton. - virtual void cleanup (void *param = 0); - - /// Explicitly delete the Singleton instance. - static void close (void); - - /// Dump the state of the object. - static void dump (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Default constructor. - ACE_Singleton (void); - - /// Contained instance. - TYPE instance_; - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - /// Pointer to the Singleton (ACE_Cleanup) instance. - static ACE_Singleton *singleton_; -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ - - /// Get pointer to the Singleton instance. - static ACE_Singleton *&instance_i (void); -}; - -/** - * @class ACE_Unmanaged_Singleton - * - * @brief Same as ACE_Singleton, except does _not_ register with - * ACE_Object_Manager for destruction. - * - * This version of ACE_Singleton can be used if, for example, - * its DLL will be unloaded before the ACE_Object_Manager - * destroys the instance. Unlike with ACE_Singleton, the - * application is responsible for explicitly destroying the - * instance after it is no longer needed (if it wants to avoid - * memory leaks, at least). The close() static member function - * must be used to explicitly destroy the Singleton. - * Usage is the same as for ACE_Singleton, but note that if you - * you declare a friend, the friend class must still be an - * *ACE_Singleton*, not an ACE_Unmanaged_Singleton. - */ -template -class ACE_Unmanaged_Singleton : public ACE_Singleton -{ -public: - /// Global access point to the Singleton. - static TYPE *instance (void); - - /// Explicitly delete the Singleton instance. - static void close (void); - - /// Dump the state of the object. - static void dump (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Default constructor. - ACE_Unmanaged_Singleton (void); - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - /// Pointer to the Singleton (ACE_Cleanup) instance. - static ACE_Unmanaged_Singleton *singleton_; -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ - - /// Get pointer to the Singleton instance. - static ACE_Unmanaged_Singleton *&instance_i (void); -}; - -/** - * @class ACE_TSS_Singleton - * - * @brief This class uses the Adapter pattern to turn ordinary classes - * into Thread-specific Singletons optimized with the - * Double-Checked Locking optimization pattern. - * - * This implementation is another variation on the GoF Singleton - * pattern. In this case, a single > instance is allocated here, not a instance. - * Each call to the static method returns a Singleton - * whose pointer resides in thread-specific storage. As with - * ACE_Singleton, we use the ACE_Object_Manager so that the - * Singleton can be cleaned up when the process exits. For this - * scheme to work, a (static) cleanup() function must be - * provided. ACE_Singleton provides one so that TYPE doesn't - * need to. - */ -template -class ACE_TSS_Singleton : public ACE_Cleanup -{ -public: - /// Global access point to the singleton. - static TYPE *instance (void); - - /// Cleanup method, used by to destroy the - /// singleton. - virtual void cleanup (void *param = 0); - - /// Dump the state of the object. - static void dump (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Default constructor. - ACE_TSS_Singleton (void); - - /// Contained instance. - ACE_TSS_TYPE (TYPE) instance_; - - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_TSS_Singleton &)) - ACE_UNIMPLEMENTED_FUNC (ACE_TSS_Singleton (const ACE_TSS_Singleton &)) - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - /// Pointer to the Singleton (ACE_Cleanup) instance. - static ACE_TSS_Singleton *singleton_; -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ - - /// Get pointer to the TSS Singleton instance. - static ACE_TSS_Singleton *&instance_i (void); -}; - -/** - * @class ACE_Unmanaged_TSS_Singleton - * - * @brief Same as ACE_TSS_Singleton, except does _not_ register with - * ACE_Object_Manager for destruction. - * - * This version of ACE_TSS_Singleton can be used if, for example, its DLL will - * be unloaded before the ACE_Object_Manager destroys the instance. Unlike with - * ACE_Singleton, the application is responsible for explicitly destroying the - * instance after it is no longer needed (if it wants to avoid memory leaks, - * at least). The close() static member function must be used to explicitly - * destroy the Singleton. - */ -template -class ACE_Unmanaged_TSS_Singleton : public ACE_TSS_Singleton -{ -public: - /// Global access point to the singleton. - static TYPE *instance (void); - - /// Explicitly delete the singleton instance. - static void close (void); - - /// Dump the state of the object. - static void dump (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Default constructor. - ACE_Unmanaged_TSS_Singleton (void); - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - /// Pointer to the Singleton (ACE_Cleanup) instance. - static ACE_Unmanaged_TSS_Singleton *singleton_; -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ - - /// Get pointer to the Singleton instance. - static ACE_Unmanaged_TSS_Singleton *&instance_i (void); -}; - -/** - * @class ACE_DLL_Singleton_T - * - * @brief Same as ACE_Singleton, except that it registers for - * destruction with the ACE_Framework_Repository instead of - * with the ACE_Object_Manager directly. - * - * This version of ACE_Singleton should be used for singletons - * that live in a dll loaded either directly by ACE_DLL or indirectly - * by the ACE Service Configuration framework. Whenever ACE_DLL is ready - * to actually unload the dll, ACE_DLL_Singleton based dlls associated - * with that dll will be destroyed first. In fact, any singleton can - * safely use ACE_DLL_Singleton, even those that don't live in dlls. In - * that case, the singleton will be destroyed at normal program shutdown. - * - * The only additional requirement is that the contained class - * export name() and dll_name() methods. See ACE_DLL_Singleton_Adapter_T - * below for a convenient example of how to satisfy this - * requirement for the dll_name(). - * - * Usage is the same as for ACE_Singleton, but note that if you - * you declare a friend, the friend class must still be an - * *ACE_Singleton*, not an ACE_Unmanaged_Singleton. - */ -template -class ACE_DLL_Singleton_T -{ -public: - //void cleanup (void *param = 0); - - /// Global access point to the Singleton. - static TYPE *instance (void); - - /// Explicitly delete the Singleton instance. - static void close (void); - - static void close_singleton (void); - - /// Dump the state of the object. - static void dump (void); - - const ACE_TCHAR *dll_name (void); - - const ACE_TCHAR *name (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Default constructor. - ACE_DLL_Singleton_T (void); - - /// Destructor. - ~ACE_DLL_Singleton_T (void); - - /// Contained instance. - TYPE instance_; - -#if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES) - /// Pointer to the Singleton instance. - static ACE_DLL_Singleton_T *singleton_; -#endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */ - - /// Get pointer to the singleton instance. - static ACE_DLL_Singleton_T *&instance_i (void); -}; - -template -class ACE_DLL_Singleton_Adapter_T : public TYPE -{ -public: - const ACE_TCHAR *dll_name (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Singleton.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Singleton.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Singleton.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_SINGLETON_H */ diff --git a/deps/acelite/ace/Singleton.inl b/deps/acelite/ace/Singleton.inl deleted file mode 100644 index 912271ba2..000000000 --- a/deps/acelite/ace/Singleton.inl +++ /dev/null @@ -1,39 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Default constructors. -// -// Note: don't explicitly initialize "instance_", because TYPE may not -// have a default constructor. Let the compiler figure it out . . . - -template ACE_INLINE -ACE_Singleton::ACE_Singleton (void) -{ -} - -template ACE_INLINE -ACE_Unmanaged_Singleton::ACE_Unmanaged_Singleton (void) -{ -} - -template ACE_INLINE -ACE_TSS_Singleton::ACE_TSS_Singleton (void) -{ -} - -template ACE_INLINE -ACE_Unmanaged_TSS_Singleton::ACE_Unmanaged_TSS_Singleton (void) -{ -} - -template ACE_INLINE -ACE_DLL_Singleton_T::ACE_DLL_Singleton_T (void) -{ -} - -template -ACE_DLL_Singleton_T::~ACE_DLL_Singleton_T (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Sock_Connect.cpp b/deps/acelite/ace/Sock_Connect.cpp deleted file mode 100644 index 43606fa2f..000000000 --- a/deps/acelite/ace/Sock_Connect.cpp +++ /dev/null @@ -1,1536 +0,0 @@ -#include "ace/Sock_Connect.h" -#include "ace/INET_Addr.h" -#include "ace/Log_Category.h" -#include "ace/Handle_Set.h" -#include "ace/Auto_Ptr.h" -#include "ace/SString.h" -#include "ace/OS_Memory.h" -#include "ace/OS_NS_stdio.h" -#include "ace/ACE.h" - -#if defined (sparc) -# include "ace/OS_NS_fcntl.h" -#endif // sparc - -#include "ace/OS_NS_stdlib.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_NS_sys_socket.h" -#include "ace/OS_NS_netdb.h" -#include "ace/OS_NS_unistd.h" -#include "ace/os_include/net/os_if.h" - -#if defined (ACE_HAS_IPV6) -# include "ace/Guard_T.h" -# include "ace/Recursive_Thread_Mutex.h" -# if defined (_AIX) -# include /**/ -# endif /* _AIX */ -#endif /* ACE_HAS_IPV6 */ - -#if defined (ACE_HAS_GETIFADDRS) -# include "ace/os_include/os_ifaddrs.h" -#endif /* ACE_HAS_GETIFADDRS */ - -#if defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x670) && defined (__RTP__) && defined (ACE_HAS_IPV6) -const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT; -const struct in6_addr in6addr_nodelocal_allnodes = IN6ADDR_NODELOCAL_ALLNODES_INIT; -const struct in6_addr in6addr_linklocal_allnodes = IN6ADDR_LINKLOCAL_ALLNODES_INIT; -const struct in6_addr in6addr_linklocal_allrouters = IN6ADDR_LINKLOCAL_ALLROUTERS_INIT; -#endif /* ACE_VXWORKS <= 0x670 && __RTP__ && ACE_HAS_IPV6 */ - -#if defined (ACE_HAS_WINCE) -#include /**/ -# if defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) && (_WIN32_WCE < 0x600) && defined (ACE_HAS_IPV6) -# include /**/ -const struct in6_addr in6addr_any = IN6ADDR_ANY_INIT; -const struct in6_addr in6addr_loopback = IN6ADDR_LOOPBACK_INIT; -# endif -#endif // ACE_HAS_WINCE - -#if defined (ACE_WIN32) && defined (ACE_HAS_PHARLAP) -# include "ace/OS_NS_stdio.h" -#endif - -#if defined (ACE_HAS_IPV6) - -// These defines support a generic usage based on -// the various SIGCF*IF ioctl implementations - -# if defined (SIOCGLIFCONF) -# define SIOCGIFCONF_CMD SIOCGLIFCONF -# if defined (__hpux) -# define IFREQ if_laddrreq -# define IFCONF if_laddrconf -# define IFC_REQ iflc_req -# define IFC_LEN iflc_len -# define IFC_BUF iflc_buf -# define IFR_ADDR iflr_addr -# define IFR_NAME iflr_name -# define IFR_FLAGS iflr_flags -# undef SETFAMILY -# define SA_FAMILY sa_family -# else -# define IFREQ lifreq -# define IFCONF lifconf -# define IFC_REQ lifc_req -# define IFC_LEN lifc_len -# define IFC_BUF lifc_buf -# define IFR_ADDR lifr_addr -# define IFR_NAME lifr_name -# define IFR_FLAGS lifr_flags -# define SETFAMILY -# define IFC_FAMILY lifc_family -# define IFC_FLAGS lifc_flags -# define SA_FAMILY ss_family -# endif -# else -# define SIOCGIFCONF_CMD SIOCGIFCONF -# define IFREQ ifreq -# define IFCONF ifconf -# define IFC_REQ ifc_req -# define IFC_LEN ifc_len -# define IFC_BUF ifc_buf -# define IFR_ADDR ifr_addr -# define IFR_NAME ifr_name -# define IFR_FLAGS ifr_flags -# undef SETFAMILY -# define SA_FAMILY sa_family -# endif /* SIOCGLIFCONF */ - -# if defined (ACE_HAS_THREADS) -# include "ace/Object_Manager.h" -# endif /* ACE_HAS_THREADS */ - -namespace -{ - // private: - // Used internally so not exported. - - // Does this box have ipv4 turned on? - int ace_ipv4_enabled = -1; - - // Does this box have ipv6 turned on? - int ace_ipv6_enabled = -1; - -} -#else /* ACE_HAS_IPV6 */ -# define SIOCGIFCONF_CMD SIOCGIFCONF -# define IFREQ ifreq -# define IFCONF ifconf -# define IFC_REQ ifc_req -# define IFC_LEN ifc_len -# define IFC_BUF ifc_buf -# define IFR_ADDR ifr_addr -# define IFR_NAME ifr_name -# define IFR_FLAGS ifr_flags -# undef SETFAMILY -# define SA_FAMILY sa_family -#endif /* ACE_HAS_IPV6 */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Bind socket to an unused port. - -int -ACE::bind_port (ACE_HANDLE handle, ACE_UINT32 ip_addr, int address_family) -{ - ACE_TRACE ("ACE::bind_port"); - - ACE_INET_Addr addr; - -#if defined (ACE_HAS_IPV6) - if (address_family != PF_INET6) - // What do we do if it is PF_"INET6? Since it's 4 bytes, it must be an - // IPV4 address. Is there a difference? Why is this test done? dhinton -#else /* ACE_HAS_IPV6 */ - ACE_UNUSED_ARG (address_family); -#endif /* !ACE_HAS_IPV6 */ - addr = ACE_INET_Addr ((u_short)0, ip_addr); -#if defined (ACE_HAS_IPV6) - else if (ip_addr != INADDR_ANY) - // address_family == PF_INET6 and a non default IP address means to bind - // to the IPv4-mapped IPv6 address - addr.set ((u_short)0, ip_addr, 1, 1); -#endif /* ACE_HAS_IPV6 */ - - // The OS kernel should select a free port for us. - return ACE_OS::bind (handle, - (sockaddr*)addr.get_addr(), - addr.get_size()); -} - -int -ACE::get_bcast_addr (ACE_UINT32 &bcast_addr, - const ACE_TCHAR *host_name, - ACE_UINT32 host_addr, - ACE_HANDLE handle) -{ - ACE_TRACE ("ACE::get_bcast_addr"); - -#if defined (ACE_LACKS_GET_BCAST_ADDR) - ACE_UNUSED_ARG (bcast_addr); - ACE_UNUSED_ARG (host_name); - ACE_UNUSED_ARG (host_addr); - ACE_UNUSED_ARG (handle); - ACE_NOTSUP_RETURN (-1); -#elif !defined(ACE_WIN32) && !defined(__INTERIX) - ACE_HANDLE s = handle; - - if (s == ACE_INVALID_HANDLE) - s = ACE_OS::socket (AF_INET, SOCK_STREAM, 0); - - if (s == ACE_INVALID_HANDLE) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_OS::socket")), - -1); - - struct ifconf ifc; - char buf[BUFSIZ]; - - ifc.ifc_len = sizeof buf; - ifc.ifc_buf = buf; - - // Get interface structure and initialize the addresses using UNIX - // techniques - if (ACE_OS::ioctl (s, SIOCGIFCONF_CMD, (char *) &ifc) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::get_bcast_addr:") - ACE_TEXT ("ioctl (get interface configuration)")), - -1); - - struct ifreq *ifr = ifc.ifc_req; - - struct sockaddr_in ip_addr; - - // Get host ip address if necessary. - if (host_name) - { - hostent *hp = ACE_OS::gethostbyname (ACE_TEXT_ALWAYS_CHAR (host_name)); - - if (hp == 0) - return -1; - else - ACE_OS::memcpy ((char *) &ip_addr.sin_addr.s_addr, -# ifdef ACE_HOSTENT_H_ADDR - (char *) hp->ACE_HOSTENT_H_ADDR, -# else - (char *) hp->h_addr, -# endif - hp->h_length); - } - else - { - ACE_OS::memset ((void *) &ip_addr, 0, sizeof ip_addr); - ACE_OS::memcpy ((void *) &ip_addr.sin_addr, - (void*) &host_addr, - sizeof ip_addr.sin_addr); - } - -#if !defined(AIX) && !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (__Lynx__) - for (int n = ifc.ifc_len / sizeof (struct ifreq) ; n > 0; - n--, ifr++) -#else - // see mk_broadcast@SOCK_Dgram_Bcast.cpp - for (int nbytes = ifc.ifc_len; nbytes >= (int) sizeof (struct ifreq) && - ((ifr->ifr_addr.sa_len > sizeof (struct sockaddr)) ? - (nbytes >= (int) sizeof (ifr->ifr_name) + ifr->ifr_addr.sa_len) : 1); - ((ifr->ifr_addr.sa_len > sizeof (struct sockaddr)) ? - (nbytes -= sizeof (ifr->ifr_name) + ifr->ifr_addr.sa_len, - ifr = (struct ifreq *) - ((caddr_t) &ifr->ifr_addr + ifr->ifr_addr.sa_len)) : - (nbytes -= sizeof (struct ifreq), ifr++))) -#endif /* !defined(AIX) && !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (__Lynx__) */ - { - struct sockaddr_in if_addr; - - // Compare host ip address with interface ip address. - ACE_OS::memcpy (&if_addr, - &ifr->ifr_addr, - sizeof if_addr); - - if (ip_addr.sin_addr.s_addr != if_addr.sin_addr.s_addr) - continue; - - if (ifr->ifr_addr.sa_family != AF_INET) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::get_bcast_addr:") - ACE_TEXT ("Not AF_INET"))); - continue; - } - - struct ifreq flags = *ifr; - struct ifreq if_req = *ifr; - - if (ACE_OS::ioctl (s, SIOCGIFFLAGS, (char *) &flags) == -1) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::get_bcast_addr:") - ACE_TEXT (" ioctl (get interface flags)"))); - continue; - } - - if (ACE_BIT_DISABLED (flags.ifr_flags, IFF_UP)) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::get_bcast_addr:") - ACE_TEXT ("Network interface is not up"))); - continue; - } - - if (ACE_BIT_ENABLED (flags.ifr_flags, IFF_LOOPBACK)) - continue; - - if (ACE_BIT_ENABLED (flags.ifr_flags, IFF_BROADCAST)) - { - if (ACE_OS::ioctl (s, - SIOCGIFBRDADDR, - (char *) &if_req) == -1) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::get_bcast_addr:") - ACE_TEXT ("ioctl (get broadaddr)"))); - else - { - ACE_OS::memcpy (&ip_addr, - &if_req.ifr_broadaddr, - sizeof if_req.ifr_broadaddr); - - ACE_OS::memcpy ((void *) &host_addr, - (void *) &ip_addr.sin_addr, - sizeof host_addr); - - if (handle == ACE_INVALID_HANDLE) - ACE_OS::close (s); - - bcast_addr = host_addr; - return 0; - } - } - else - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::get_bcast_addr:") - ACE_TEXT ("Broadcast is not enabled for this interface."))); - - if (handle == ACE_INVALID_HANDLE) - ACE_OS::close (s); - - bcast_addr = host_addr; - return 0; - } - - return 0; -#else - ACE_UNUSED_ARG (handle); - ACE_UNUSED_ARG (host_addr); - ACE_UNUSED_ARG (host_name); - bcast_addr = (ACE_UINT32 (INADDR_BROADCAST)); - return 0; -#endif /* !ACE_WIN32 && !__INTERIX */ -} - -int -ACE::get_fqdn (ACE_INET_Addr const & addr, - char hostname[], - size_t len) -{ -#ifndef ACE_LACKS_GETNAMEINFO - - const socklen_t addr_size = -# ifdef ACE_HAS_IPV6 - (addr.get_type () == PF_INET6) ? sizeof (sockaddr_in6) : -# endif - sizeof (sockaddr_in); - - if (ACE_OS::getnameinfo ((const sockaddr *) addr.get_addr (), - addr_size, hostname, - static_cast (len), - 0, 0, NI_NAMEREQD) != 0) - return -1; - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%P|%t) - ACE::get_fqdn, ") - ACE_TEXT ("canonical host name is %C\n"), - hostname)); - - return 0; -#else // below, ACE_LACKS_GETNAMEINFO - int h_error; // Not the same as errno! - hostent hentry; - ACE_HOSTENT_DATA buf; - - char * ip_addr = 0; - int ip_addr_size = 0; - if (addr.get_type () == AF_INET) - { - sockaddr_in * const sock_addr = - reinterpret_cast (addr.get_addr ()); - ip_addr_size = sizeof sock_addr->sin_addr; - ip_addr = (char*) &sock_addr->sin_addr; - } -# ifdef ACE_HAS_IPV6 - else - { - sockaddr_in6 * sock_addr = - reinterpret_cast (addr.get_addr ()); - - ip_addr_size = sizeof sock_addr->sin6_addr; - ip_addr = (char*) &sock_addr->sin6_addr; - } -# endif /* ACE_HAS_IPV6 */ - - // get the host entry for the address in question - hostent * const hp = ACE_OS::gethostbyaddr_r (ip_addr, - ip_addr_size, - addr.get_type (), - &hentry, - buf, - &h_error); - - // if it's not found in the host file or the DNS datase, there is nothing - // much we can do. embed the IP address - if (hp == 0 || hp->h_name == 0) - return -1; - - if (ACE::debug()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%P|%t) - ACE::get_fqdn, ") - ACE_TEXT ("canonical host name is %C\n"), - hp->h_name)); - - // check if the canonical name is the FQDN - if (!ACE_OS::strchr(hp->h_name, '.')) - { - // list of address - char** p; - // list of aliases - char** q; - - // for every address and for every alias within the address, check and - // see if we can locate a FQDN - for (p = hp->h_addr_list; *p != 0; ++p) - { - for (q = hp->h_aliases; *q != 0; ++q) - { - if (ACE_OS::strchr(*q, '.')) - { - // we got an FQDN from an alias. use this - if (ACE_OS::strlen (*q) >= len) - // the hostname is too huge to fit into a - // buffer of size MAXHOSTNAMELEN - // should we check other aliases as well - // before bailing out prematurely? - // for right now, let's do it. this (short name) - // is atleast better than embedding the IP - // address in the profile - continue; - - if (ACE::debug ()) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("(%P|%t) - ACE::get_fqdn, ") - ACE_TEXT ("found fqdn within alias as %C\n"), - *q)); - ACE_OS::strcpy (hostname, *q); - - return 0; - } - } - } - } - - // The canonical name may be an FQDN when we reach here. - // Alternatively, the canonical name (a non FQDN) may be the best - // we can do. - if (ACE_OS::strlen (hp->h_name) >= len) - { - // The hostname is too large to fit into a buffer of size - // MAXHOSTNAMELEN. - return -2; - } - else - { - ACE_OS::strcpy (hostname, hp->h_name); - } - - return 0; -#endif /* ACE_LACKS_GETNAMEINFO */ -} - -#if defined (ACE_WIN32) - -static int -get_ip_interfaces_win32 (size_t &count, - ACE_INET_Addr *&addrs) -{ -# if defined (ACE_HAS_WINCE) && defined (ACE_HAS_WINSOCK2) && (ACE_HAS_WINSOCK2 != 0) - // moved the ACE_HAS_WINCE impl ahaid of ACE_HAS_WINSOCK2 because - // WINCE in fact has winsock2, but doesn't properly support the - // WSAIoctl for obtaining IPv6 address info. - PIP_ADAPTER_ADDRESSES AdapterAddresses = 0; - ULONG OutBufferLength = 0; - ULONG RetVal = 0; - unsigned char *octet_buffer = 0; - - RetVal = - GetAdaptersAddresses(AF_UNSPEC, - 0, - 0, - AdapterAddresses, - &OutBufferLength); - - if (RetVal != ERROR_BUFFER_OVERFLOW) - { - return -1; - } - - ACE_NEW_RETURN (octet_buffer, unsigned char[OutBufferLength],-1); - AdapterAddresses = (IP_ADAPTER_ADDRESSES *)octet_buffer; - - RetVal = - GetAdaptersAddresses(AF_UNSPEC, - 0, - 0, - AdapterAddresses, - &OutBufferLength); - - if (RetVal != NO_ERROR) - { - delete [] octet_buffer; - return -1; - } - - // If successful, output some information from the data we received - PIP_ADAPTER_ADDRESSES AdapterList = AdapterAddresses; - while (AdapterList) - { - if (AdapterList->OperStatus == IfOperStatusUp) - { - if (AdapterList->IfIndex != 0) - ++count; - if (AdapterList->Ipv6IfIndex != 0) - ++count; - } - AdapterList = AdapterList->Next; - } - - AdapterList = AdapterAddresses; - - ACE_NEW_RETURN (addrs, ACE_INET_Addr[count],-1); - count = 0; - for (AdapterList = AdapterAddresses; - AdapterList != 0; - AdapterList = AdapterList->Next) - { - if (AdapterList->OperStatus != IfOperStatusUp) - continue; - - IP_ADAPTER_UNICAST_ADDRESS *uni = 0; - if (AdapterList->IfIndex != 0) - for (uni = AdapterList->FirstUnicastAddress; - uni != 0; - uni = uni->Next) - { - SOCKET_ADDRESS *sa_addr = &uni->Address; - if (sa_addr->lpSockaddr->sa_family == AF_INET) - { - sockaddr_in *sin = (sockaddr_in*)sa_addr->lpSockaddr; - addrs[count].set(sin,sa_addr->iSockaddrLength); - ++count; - break; - } - } - if (AdapterList->Ipv6IfIndex != 0) - { - for (uni = AdapterList->FirstUnicastAddress; - uni != 0; - uni = uni->Next) - { - SOCKET_ADDRESS *sa_addr = &uni->Address; - if (sa_addr->lpSockaddr->sa_family == AF_INET6) - { - sockaddr_in *sin = (sockaddr_in*)sa_addr->lpSockaddr; - addrs[count].set(sin,sa_addr->iSockaddrLength); - ++count; - break; - } - } - } - } - - delete [] octet_buffer; - return 0; - -# elif defined (ACE_HAS_PHARLAP) - // PharLap ETS has its own kernel routines to rummage through the device - // configs and extract the interface info, but only for Pharlap RT. -# if !defined (ACE_HAS_PHARLAP_RT) - ACE_NOTSUP_RETURN (-1); -# endif /* ACE_HAS_PHARLAP_RT */ - - // Locate all of the IP devices in the system, saving a DEVHANDLE - // for each. Then allocate the ACE_INET_Addrs needed and fetch all - // the IP addresses. To locate the devices, try the available - // device name roots and increment the device number until the - // kernel says there are no more of that type. - const size_t ACE_MAX_ETS_DEVICES = 64; // Arbitrary, but should be enough. - DEVHANDLE ip_dev[ACE_MAX_ETS_DEVICES]; - EK_TCPIPCFG *devp = 0; - size_t i, j; - ACE_TCHAR dev_name[16]; - - count = 0; - for (i = 0; count < ACE_MAX_ETS_DEVICES; i++, ++count) - { - // Ethernet. - ACE_OS::sprintf (dev_name, - "ether%d", - i); - ip_dev[count] = EtsTCPGetDeviceHandle (dev_name); - if (ip_dev[count] == 0) - break; - } - for (i = 0; count < ACE_MAX_ETS_DEVICES; i++, ++count) - { - // SLIP. - ACE_OS::sprintf (dev_name, - "sl%d", - i); - ip_dev[count] = EtsTCPGetDeviceHandle (dev_name); - if (ip_dev[count] == 0) - break; - } - for (i = 0; count < ACE_MAX_ETS_DEVICES; i++, ++count) - { - // PPP. - ACE_OS::sprintf (dev_name, - "ppp%d", - i); - ip_dev[count] = EtsTCPGetDeviceHandle (dev_name); - if (ip_dev[count] == 0) - break; - } - - if (count > 0) - ACE_NEW_RETURN (addrs, - ACE_INET_Addr[count], - -1); - else - addrs = 0; - - for (i = 0, j = 0; i < count; i++) - { - devp = EtsTCPGetDeviceCfg (ip_dev[i]); - if (devp != 0) - { - addrs[j].set (0, - devp->nwIPAddress, - 0); // Already in net order. - ++j; - } - // There's no call to close the DEVHANDLE. - } - - count = j; - if (count == 0 && addrs != 0) - { - delete [] addrs; - addrs = 0; - } - - return 0; - - -# else - // All non-CE, non-Pharlap Windows. Must support Winsock2. - - int i, n_interfaces, status; - - INTERFACE_INFO info[64]; - SOCKET sock; - - // Get an (overlapped) DGRAM socket to test with - sock = socket (AF_INET, SOCK_DGRAM, 0); - if (sock == INVALID_SOCKET) - return -1; - - DWORD bytes; - status = WSAIoctl(sock, - SIO_GET_INTERFACE_LIST, - 0, - 0, - info, - sizeof(info), - &bytes, - 0, - 0); - closesocket (sock); - if (status == SOCKET_ERROR) - return -1; - - n_interfaces = bytes / sizeof(INTERFACE_INFO); - - // SIO_GET_INTERFACE_LIST does not work for IPv6 - // Instead recent versions of Winsock2 add the new opcode - // SIO_ADDRESS_LIST_QUERY. - // If this is not available forget about IPv6 local interfaces:-/ - int n_v6_interfaces = 0; - -# if defined (ACE_HAS_IPV6) && defined (SIO_ADDRESS_LIST_QUERY) - - LPSOCKET_ADDRESS_LIST v6info; - char *buffer; - DWORD buflen = sizeof (SOCKET_ADDRESS_LIST) + (63 * sizeof (SOCKET_ADDRESS)); - ACE_NEW_RETURN (buffer, - char[buflen], - -1); - v6info = reinterpret_cast (buffer); - - // Get an (overlapped) DGRAM socket to test with. - // If it fails only return IPv4 interfaces. - sock = socket (AF_INET6, SOCK_DGRAM, IPPROTO_UDP); - if (sock != INVALID_SOCKET) - { - status = WSAIoctl(sock, - SIO_ADDRESS_LIST_QUERY, - 0, - 0, - v6info, - buflen, - &bytes, - 0, - 0); - closesocket (sock); - if (status != SOCKET_ERROR) - n_v6_interfaces = v6info->iAddressCount; - } -# endif /* ACE_HAS_IPV6 */ - - ACE_NEW_RETURN (addrs, - ACE_INET_Addr[n_interfaces + n_v6_interfaces], - -1); - - // Now go through the list and transfer the good ones to the list of - // because they're down or don't have an IP address. - for (count = 0, i = 0; i < n_interfaces; ++i) - { - LPINTERFACE_INFO lpii; - struct sockaddr_in *addrp = 0; - - lpii = &info[i]; - if (!(lpii->iiFlags & IFF_UP)) - continue; - - // We assume IPv4 addresses here - addrp = reinterpret_cast (&lpii->iiAddress.AddressIn); - if (addrp->sin_addr.s_addr == INADDR_ANY) - continue; - - // Set the address for the caller. - addrs[count].set(addrp, sizeof(sockaddr_in)); - ++count; - } - -# if defined (ACE_HAS_IPV6) && defined (SIO_ADDRESS_LIST_QUERY) - // Now go through the list and transfer the good ones to the list of - // because they're down or don't have an IP address. - for (i = 0; i < n_v6_interfaces; i++) - { - struct sockaddr_in6 *addr6p; - - if (v6info->Address[i].lpSockaddr->sa_family != AF_INET6) - continue; - - addr6p = reinterpret_cast (v6info->Address[i].lpSockaddr); - if (IN6_IS_ADDR_UNSPECIFIED(&addr6p->sin6_addr)) // IN6ADDR_ANY? - continue; - - // Set the address for the caller. - addrs[count].set(reinterpret_cast (addr6p), sizeof(sockaddr_in6)); - ++count; - } - - delete [] buffer; // Clean up -# endif /* ACE_HAS_IPV6 */ - - if (count == 0) - { - delete [] addrs; - addrs = 0; - } - - return 0; - -# endif /* ACE_HAS_WINCE */ -} - -#elif defined (ACE_HAS_GETIFADDRS) -static int -get_ip_interfaces_getifaddrs (size_t &count, - ACE_INET_Addr *&addrs) -{ - // Take advantage of the BSD getifaddrs function that simplifies - // access to connected interfaces. - struct ifaddrs *ifap = 0; - struct ifaddrs *p_if = 0; - - if (::getifaddrs (&ifap) != 0) - return -1; - - // Count number of interfaces. - size_t num_ifs = 0; - for (p_if = ifap; p_if != 0; p_if = p_if->ifa_next) - ++num_ifs; - - // Now create and initialize output array. - ACE_NEW_RETURN (addrs, - ACE_INET_Addr[num_ifs], - -1); // caller must free - - // Pull the address out of each INET interface. Not every interface - // is for IP, so be careful to count properly. When setting the - // INET_Addr, note that the 3rd arg (0) says to leave the byte order - // (already in net byte order from the interface structure) as is. - count = 0; - - for (p_if = ifap; - p_if != 0; - p_if = p_if->ifa_next) - { - if (p_if->ifa_addr == 0) - continue; - - // Check to see if it's up. - if ((p_if->ifa_flags & IFF_UP) != IFF_UP) - continue; - - if (p_if->ifa_addr->sa_family == AF_INET) - { - struct sockaddr_in *addr = - reinterpret_cast (p_if->ifa_addr); - - // Sometimes the kernel returns 0.0.0.0 as the interface - // address, skip those... - if (addr->sin_addr.s_addr != INADDR_ANY) - { - addrs[count].set ((u_short) 0, - addr->sin_addr.s_addr, - 0); - ++count; - } - } -# if defined (ACE_HAS_IPV6) - else if (p_if->ifa_addr->sa_family == AF_INET6) - { - struct sockaddr_in6 *addr = - reinterpret_cast (p_if->ifa_addr); - - // Skip the ANY address - if (!IN6_IS_ADDR_UNSPECIFIED(&addr->sin6_addr)) - { - addrs[count].set(reinterpret_cast (addr), - sizeof(sockaddr_in6)); - ++count; - } - } -# endif /* ACE_HAS_IPV6 */ - } - - ::freeifaddrs (ifap); - - return 0; -} -#elif defined (__hpux) -static int -get_ip_interfaces_hpux (size_t &count, - ACE_INET_Addr *&addrs) -{ - size_t num_ifs = 0; - size_t num_ifs_found = 0; - - // Call specific routine as necessary. - ACE_HANDLE handle = ACE_OS::socket (PF_INET, SOCK_DGRAM, 0); - ACE_HANDLE handle_ipv6 = ACE_INVALID_HANDLE; - - if (handle == ACE_INVALID_HANDLE) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::get_ip_interfaces:open")), - -1); - - int result = 0; - int tmp_how_many = 0; - - result = ACE_OS::ioctl (handle, - SIOCGIFNUM, - (caddr_t) &tmp_how_many); - if (result != -1) - num_ifs = (size_t)tmp_how_many; - -# if defined (ACE_HAS_IPV6) - tmp_how_many = 0; - handle_ipv6 = ACE_OS::socket (PF_INET6, SOCK_DGRAM, 0); - result = ACE_OS::ioctl (handle_ipv6, - SIOCGLIFNUM, - (caddr_t) &tmp_how_many); - if (result != -1) - num_ifs += (size_t)tmp_how_many; -# endif - - if (num_ifs == 0) - { - ACE_OS::close (handle); - ACE_OS::close (handle_ipv6); - return -1; - } - - // ioctl likes to have an extra IFREQ structure to mark the end of - // what it returned, so increase the num_ifs by one. - ++num_ifs; - - //HPUX requires two passes, First for IPv4, then for IPv6 - - struct ifreq *ifs = 0; - ACE_NEW_RETURN (ifs, - struct ifreq[num_ifs], - -1); - ACE_OS::memset (ifs, 0, num_ifs * sizeof (struct ifreq)); - - ACE_Auto_Array_Ptr p_ifs (ifs); - - if (p_ifs.get() == 0) - { - ACE_OS::close (handle); - ACE_OS::close (handle_ipv6); - errno = ENOMEM; - return -1; - } - - struct ifconf ifcfg; - ACE_OS::memset (&ifcfg, 0, sizeof (struct ifconf)); - - ifcfg.ifc_req = p_ifs.get (); - ifcfg.ifc_len = num_ifs * sizeof (struct ifreq); - - if (ACE_OS::ioctl (handle, - SIOCGIFCONF, - (char *) &ifcfg) == -1) - { - ACE_OS::close (handle); - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::get_ip_interfaces:") - ACE_TEXT ("ioctl - SIOCGIFCONF failed")), - -1); - } - - ACE_OS::close (handle); - - // Now create and initialize output array. - - ACE_NEW_RETURN (addrs, - ACE_INET_Addr[num_ifs], - -1); // caller must free - - struct ifreq *pcur = p_ifs.get (); - num_ifs_found = ifcfg.ifc_len / sizeof (struct ifreq); // get the number of returned ifs - - for (size_t i = 0; - i < num_ifs_found; - i++) - { - struct sockaddr_in *addr = - reinterpret_cast (&pcur->ifr_addr); - if (addr->sin_addr.s_addr != 0) - { - addrs[count].set ((u_short) 0, - addr->sin_addr.s_addr, - 0); - ++count; - } - ++pcur; - } - -# if defined (ACE_HAS_IPV6) - - if (handle_ipv6 != ACE_INVALID_HANDLE) - { - struct if_laddrreq *lifs = 0; - ACE_NEW_RETURN (lifs, - struct if_laddrreq[num_ifs], - -1); - ACE_OS::memset (lifs, 0, num_ifs * sizeof (struct if_laddrreq)); - - ACE_Auto_Array_Ptr p_lifs (lifs); - - if (p_lifs.get() == 0) - { - ACE_OS::close (handle); - ACE_OS::close (handle_ipv6); - errno = ENOMEM; - return -1; - } - - struct if_laddrconf lifcfg; - ACE_OS::memset (&lifcfg, 0, sizeof (struct if_laddrconf)); - - lifcfg.iflc_req = p_lifs.get (); - lifcfg.iflc_len = num_ifs * sizeof (struct if_laddrreq); - - if (ACE_OS::ioctl (handle_ipv6, - SIOCGLIFCONF, - (char *) &lifcfg) == -1) - { - ACE_OS::close (handle); - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::get_ip_interfaces:") - ACE_TEXT ("ioctl - SIOCGLIFCONF failed")), - -1); - } - - ACE_OS::close (handle_ipv6); - - struct if_laddrreq *plcur = p_lifs.get (); - num_ifs_found = lifcfg.iflc_len / sizeof (struct if_laddrreq); - - for (size_t i = 0; - i < num_ifs_found; - i++) - { - struct sockaddr_in *addr = - reinterpret_cast (&plcur->iflr_addr); - if (!IN6_IS_ADDR_UNSPECIFIED(&reinterpret_cast(addr)->sin6_addr)) - { - addrs[count].set(addr, sizeof(struct sockaddr_in6)); - ++count; - } - ++plcur; - } - } -# endif /* ACE_HAS_IPV6 */ - return 0; -} -#elif defined (_AIX) -static int -get_ip_interfaces_aix (size_t &count, - ACE_INET_Addr *&addrs) -{ - ACE_HANDLE handle = ACE::get_handle(); - size_t num_ifs = 0; - struct ifconf ifc; - - if (handle == ACE_INVALID_HANDLE) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::get_ip_interfaces_aix:")), - -1); - - if (ACE_OS::ioctl (handle, - SIOCGSIZIFCONF, - (caddr_t)&ifc.ifc_len) == -1) - { - ACE_OS::close (handle); - ACELIB_ERROR_RETURN((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("get ifconf size")), - -1); - } - - ACE_NEW_RETURN (ifc.ifc_buf,char [ifc.ifc_len], -1); - - ACE_Auto_Array_Ptr safe_buf (ifc.ifc_buf); - ACE_OS::memset (safe_buf.get(), 0, ifc.ifc_len); - - if (ACE_OS::ioctl(handle, SIOCGIFCONF, (caddr_t)&ifc) == -1) - { - ACE_OS::close (handle); - ACELIB_ERROR_RETURN((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("get ifconf")), - -1); - } - - ACE_OS::close (handle); - - char *buf_start = safe_buf.get(); - char *buf_end = buf_start + ifc.ifc_len; - - num_ifs = 0; - for (char *ptr = buf_start; ptr < buf_end; ) - { - struct ifreq *req = reinterpret_cast(ptr); - ptr += IFNAMSIZ; - ptr += req->ifr_addr.sa_len; - if (req->ifr_addr.sa_family == AF_INET -# if defined (ACE_HAS_IPV6) - || req->ifr_addr.sa_family == AF_INET6 -# endif - ) - ++num_ifs; - } - ACE_NEW_RETURN (addrs,ACE_INET_Addr[num_ifs], -1); - - for (char * ptr = buf_start; ptr < buf_end; ) - { - struct ifreq *req = reinterpret_cast(ptr); - // skip the interface name - ptr += IFNAMSIZ; - if (req->ifr_addr.sa_family == AF_INET -# if defined (ACE_HAS_IPV6) - || req->ifr_addr.sa_family == AF_INET6 -# endif - ) - { - sockaddr_in *addr = (sockaddr_in*)&req->ifr_addr; - addrs[count++].set(addr, addr->sin_len); - } - ptr += req->ifr_addr.sa_len; - } - - return 0; -} - -#endif // ACE_WIN32 || ACE_HAS_GETIFADDRS || __hpux || _AIX - - -// return an array of all configured IP interfaces on this host, count -// rc = 0 on success (count == number of interfaces else -1 caller is -// responsible for calling delete [] on parray - -int -ACE::get_ip_interfaces (size_t &count, ACE_INET_Addr *&addrs) -{ - ACE_TRACE ("ACE::get_ip_interfaces"); - - count = 0; - addrs = 0; - -#if defined (ACE_WIN32) - return get_ip_interfaces_win32 (count, addrs); -#elif defined (ACE_HAS_GETIFADDRS) - return get_ip_interfaces_getifaddrs (count, addrs); -#elif defined (__hpux) - return get_ip_interfaces_hpux (count, addrs); -#elif defined (_AIX) - return get_ip_interfaces_aix (count, addrs); -#elif (defined (__unix) || defined (__unix__) || defined (ACE_OPENVMS) || (defined (ACE_VXWORKS) && !defined (ACE_HAS_GETIFADDRS)) || defined (ACE_HAS_RTEMS)) && !defined (ACE_LACKS_NETWORKING) - // COMMON (SVR4 and BSD) UNIX CODE - - // Call specific routine as necessary. - ACE_HANDLE handle = ACE::get_handle(); - - if (handle == ACE_INVALID_HANDLE) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::get_ip_interfaces:open")), - -1); - - size_t num_ifs = 0; - - if (ACE::count_interfaces (handle, num_ifs)) - { - ACE_OS::close (handle); - return -1; - } - - // ioctl likes to have an extra ifreq structure to mark the end of - // what it returned, so increase the num_ifs by one. - ++num_ifs; - - struct IFREQ *ifs = 0; - ACE_NEW_RETURN (ifs, - struct IFREQ[num_ifs], - -1); - ACE_OS::memset (ifs, 0, num_ifs * sizeof (struct IFREQ)); - - ACE_Auto_Array_Ptr p_ifs (ifs); - - if (p_ifs.get() == 0) - { - ACE_OS::close (handle); - errno = ENOMEM; - return -1; - } - - struct IFCONF ifcfg; - ACE_OS::memset (&ifcfg, 0, sizeof (struct IFCONF)); - -# ifdef SETFAMILY - ifcfg.IFC_FAMILY = AF_UNSPEC; // request all families be returned - ifcfg.IFC_FLAGS = 0; -# endif - - ifcfg.IFC_REQ = p_ifs.get (); - ifcfg.IFC_LEN = num_ifs * sizeof (struct IFREQ); - - if (ACE_OS::ioctl (handle, - SIOCGIFCONF_CMD, - (caddr_t) &ifcfg) == -1) - { - ACE_OS::close (handle); - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::get_ip_interfaces:") - ACE_TEXT ("ioctl - SIOCGIFCONF failed")), - -1); - } - - ACE_OS::close (handle); - - // Now create and initialize output array. - - ACE_NEW_RETURN (addrs, - ACE_INET_Addr[num_ifs], - -1); // caller must free - - struct IFREQ *pcur = p_ifs.get (); - size_t num_ifs_found = ifcfg.IFC_LEN / sizeof (struct IFREQ); // get the number of returned ifs - - // Pull the address out of each INET interface. Not every interface - // is for IP, so be careful to count properly. When setting the - // INET_Addr, note that the 3rd arg (0) says to leave the byte order - // (already in net byte order from the interface structure) as is. - count = 0; - - for (size_t i = 0; - i < num_ifs_found; - i++) - { - if (pcur->IFR_ADDR.SA_FAMILY == AF_INET -# if defined (ACE_HAS_IPV6) - || pcur->IFR_ADDR.SA_FAMILY == AF_INET6 -# endif - ) - - { - struct sockaddr_in *addr = - reinterpret_cast (&pcur->IFR_ADDR); - - // Sometimes the kernel returns 0.0.0.0 as an IPv4 interface - // address; skip those... - if (addr->sin_addr.s_addr != 0 -# if defined (ACE_HAS_IPV6) - || (addr->sin_family == AF_INET6 && - !IN6_IS_ADDR_UNSPECIFIED(&reinterpret_cast(addr)->sin6_addr)) -# endif - ) - { - int addrlen = static_cast (sizeof (struct sockaddr_in)); -# if defined (ACE_HAS_IPV6) - if (addr->sin_family == AF_INET6) - addrlen = static_cast (sizeof (struct sockaddr_in6)); -# endif - addrs[count].set (addr, addrlen); - ++count; - } - } - -#if !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (ACE_HAS_RTEMS) && !defined (__Lynx__) - ++pcur; -#else - if (pcur->ifr_addr.sa_len <= sizeof (struct sockaddr)) - { - ++pcur; - } - else - { - pcur = (struct ifreq *) - (pcur->ifr_addr.sa_len + (caddr_t) &pcur->ifr_addr); - } -#endif /* !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (ACE_HAS_RTEMS) && !defined (__Lynx__) */ - } - -# if defined (ACE_HAS_IPV6) && !defined (ACE_LACKS_FSCANF) - // Retrieve IPv6 local interfaces by scanning /proc/net/if_inet6 if - // it exists. If we cannot open it then ignore possible IPv6 - // interfaces, we did our best;-) - FILE* fp = 0; - char addr_p[8][5]; - char s_ipaddr[64]; - int scopeid; - struct addrinfo hints, *res0; - int error; - - ACE_OS::memset (&hints, 0, sizeof (hints)); - hints.ai_flags = AI_NUMERICHOST; - hints.ai_family = AF_INET6; - - if ((fp = ACE_OS::fopen (ACE_TEXT ("/proc/net/if_inet6"), ACE_TEXT ("r"))) != 0) - { - while (fscanf (fp, - "%4s%4s%4s%4s%4s%4s%4s%4s %02x %*02x %*02x %*02x %*8s\n", - addr_p[0], addr_p[1], addr_p[2], addr_p[3], - addr_p[4], addr_p[5], addr_p[6], addr_p[7], &scopeid) != EOF) - { - // Format the address intoa proper IPv6 decimal address specification and - // resolve the resulting text using getaddrinfo(). - - const char* ip_fmt = "%s:%s:%s:%s:%s:%s:%s:%s%%%d"; - ACE_OS::snprintf (s_ipaddr, 64, ip_fmt, - addr_p[0], addr_p[1], addr_p[2], addr_p[3], - addr_p[4], addr_p[5], addr_p[6], addr_p[7], - scopeid); - - error = ACE_OS::getaddrinfo (s_ipaddr, 0, &hints, &res0); - if (error) - continue; - - if (res0->ai_family == AF_INET6 && - !IN6_IS_ADDR_UNSPECIFIED (&reinterpret_cast (res0->ai_addr)->sin6_addr)) - { - addrs[count].set(reinterpret_cast (res0->ai_addr), res0->ai_addrlen); - ++count; - } - ACE_OS::freeaddrinfo (res0); - - } - ACE_OS::fclose (fp); - } -# endif /* ACE_HAS_IPV6 && !ACE_LACKS_FSCANF */ - - return 0; -#else - ACE_UNUSED_ARG (count); - ACE_UNUSED_ARG (addrs); - ACE_NOTSUP_RETURN (-1); // no implementation -#endif /* ACE_WIN32 */ -} - -// Helper routine for get_ip_interfaces, differs by UNIX platform so -// put into own subroutine. perform some ioctls to retrieve ifconf -// list of ifreq structs. - -int -ACE::count_interfaces (ACE_HANDLE handle, size_t &how_many) -{ -#if defined (SIOCGIFNUM) -# if defined (SIOCGLIFNUM) && !defined (ACE_LACKS_STRUCT_LIFNUM) - int cmd = SIOCGLIFNUM; - struct lifnum if_num = {AF_UNSPEC,0,0}; -# else - int cmd = SIOCGIFNUM; - int if_num = 0; -# endif /* SIOCGLIFNUM */ - if (ACE_OS::ioctl (handle, cmd, (caddr_t)&if_num) == -1) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::count_interfaces:") - ACE_TEXT ("ioctl - SIOCGLIFNUM failed")), - -1); -# if defined (SIOCGLIFNUM) && !defined (ACE_LACKS_STRUCT_LIFNUM) - how_many = if_num.lifn_count; -# else - how_many = if_num; -# endif /* SIOCGLIFNUM */ -return 0; - -#elif (defined (__unix) || defined (__unix__) || defined (ACE_OPENVMS) || defined (ACE_HAS_RTEMS) || (defined (ACE_VXWORKS) && !defined (ACE_HAS_GETIFADDRS))) && !defined (ACE_LACKS_NETWORKING) - // Note: DEC CXX doesn't define "unix". BSD compatible OS: HP UX, - // AIX, SunOS 4.x perform some ioctls to retrieve ifconf list of - // ifreq structs no SIOCGIFNUM on SunOS 4.x, so use guess and scan - // algorithm - - // Probably hard to put this many ifs in a unix box.. - int const MAX_INTERFACES = 50; - - // HACK - set to an unreasonable number - int const num_ifs = MAX_INTERFACES; - - struct ifconf ifcfg; - size_t ifreq_size = num_ifs * sizeof (struct ifreq); - struct ifreq *p_ifs; - -#if defined (ACE_HAS_ALLOC_HOOKS) - p_ifs = (struct IFREQ *)ACE_Allocator::instance()->malloc (ifreq_size); -#else - p_ifs = (struct ifreq *) ACE_OS::malloc (ifreq_size); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - if (!p_ifs) - { - errno = ENOMEM; - return -1; - } - - ACE_OS::memset (p_ifs, 0, ifreq_size); - ACE_OS::memset (&ifcfg, 0, sizeof (struct ifconf)); - - ifcfg.ifc_req = p_ifs; - ifcfg.ifc_len = ifreq_size; - - if (ACE_OS::ioctl (handle, - SIOCGIFCONF_CMD, - (caddr_t) &ifcfg) == -1) - { -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (ifcfg.ifc_req); -#else - ACE_OS::free (ifcfg.ifc_req); -#endif /* ACE_HAS_ALLOC_HOOKS */ - - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE::count_interfaces:") - ACE_TEXT ("ioctl - SIOCGIFCONF failed")), - -1); - } - - int if_count = 0; - int i = 0; - - // get if address out of ifreq buffers. ioctl puts a blank-named - // interface to mark the end of the returned interfaces. - for (i = 0; - i < num_ifs; - i++) - { - /* In OpenBSD, the length of the list is returned. */ - ifcfg.ifc_len -= sizeof (struct ifreq); - if (ifcfg.ifc_len < 0) - break; - - ++if_count; -# if !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (ACE_HAS_RTEMS) && !defined (__Lynx__) - ++p_ifs; -# else - if (p_ifs->ifr_addr.sa_len <= sizeof (struct sockaddr)) - { - ++p_ifs; - } - else - { - p_ifs = (struct ifreq *) - (p_ifs->ifr_addr.sa_len + (caddr_t) &p_ifs->ifr_addr); - } -# endif /* !defined (__QNX__) && !defined (__FreeBSD__) && !defined(__NetBSD__) && !defined (ACE_HAS_RTEMS) && !defined (__Lynx__) */ - } - -#if defined (ACE_HAS_ALLOC_HOOKS) - ACE_Allocator::instance()->free (ifcfg.ifc_req); -#else - ACE_OS::free (ifcfg.ifc_req); -#endif /* ACE_HAS_ALLOC_HOOKS */ - -# if defined (ACE_HAS_IPV6) - FILE* fp = 0; - - if ((fp = ACE_OS::fopen (ACE_TEXT ("/proc/net/if_inet6"), ACE_TEXT ("r"))) != 0) - { - // Scan the lines according to the expected format but don't really read any input - while (fscanf (fp, "%*32s %*02x %*02x %*02x %*02x %*8s\n") != EOF) - { - ++if_count; - } - ACE_OS::fclose (fp); - } -# endif /* ACE_HAS_IPV6 && !ACE_LACKS_FSCANF */ - - how_many = if_count; - return 0; -#else - ACE_UNUSED_ARG (handle); - ACE_UNUSED_ARG (how_many); - ACE_NOTSUP_RETURN (-1); // no implementation -#endif /* sparc && SIOCGIFNUM */ -} - -// Routine to return a handle from which ioctl() requests can be made. - -ACE_HANDLE -ACE::get_handle (void) -{ - // Solaris 2.x - ACE_HANDLE handle = ACE_INVALID_HANDLE; -#if defined (sparc) - handle = ACE_OS::open ("/dev/udp", O_RDONLY); -#elif defined (__unix) || defined (__unix__) || defined (_AIX) || defined (__hpux) || (defined (ACE_VXWORKS) && (ACE_VXWORKS >= 0x600)) || defined (ACE_OPENVMS) || defined (ACE_HAS_RTEMS) - // Note: DEC CXX doesn't define "unix" BSD compatible OS: HP UX, - // AIX, SunOS 4.x - - handle = ACE_OS::socket (PF_INET, SOCK_DGRAM, 0); -#endif /* sparc */ - return handle; -} - - -#if defined (ACE_HAS_IPV6) -static int -ip_check (int &ipvn_enabled, int pf) -{ - // We only get to this point if ipvn_enabled was -1 in the caller. - // Perform Double-Checked Locking Optimization. - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, - *ACE_Static_Object_Lock::instance (), 0)); - - if (ipvn_enabled == -1) - { - -#if defined (ACE_WIN32) - // as of the release of Windows 2008, even hosts that have IPv6 interfaces disabled - // will still permit the creation of a PF_INET6 socket, thus rendering the socket - // creation test inconsistent. The recommended solution is to get the list of - // endpoint addresses and see if any match the desired family. - ACE_INET_Addr *if_addrs = 0; - size_t if_cnt = 0; - - ipvn_enabled = 1; // assume enabled to avoid recursion during interface lookup. - ACE::get_ip_interfaces (if_cnt, if_addrs); - ipvn_enabled = 0; - for (size_t i = 0; ipvn_enabled == 0 && i < if_cnt; i++) - { - ipvn_enabled = (if_addrs[i].get_type () == pf); - } - delete [] if_addrs; -#else - // Determine if the kernel has IPv6 support by attempting to - // create a PF_INET6 socket and see if it fails. - ACE_HANDLE const s = ACE_OS::socket (pf, SOCK_DGRAM, 0); - if (s == ACE_INVALID_HANDLE) - { - ipvn_enabled = 0; - } - else - { - ipvn_enabled = 1; - ACE_OS::closesocket (s); - } -#endif - } - return ipvn_enabled; -} -#endif /* ACE_HAS_IPV6 */ - -bool -ACE::ipv4_enabled (void) -{ -#if defined (ACE_HAS_IPV6) - return static_cast (ace_ipv4_enabled == -1 ? - ::ip_check (ace_ipv4_enabled, PF_INET) : - ace_ipv4_enabled); -#else - // Assume it's always enabled since ACE requires some version of - // TCP/IP to exist. - return true; -#endif /* ACE_HAS_IPV6*/ -} - -int -ACE::ipv6_enabled (void) -{ -#if defined (ACE_HAS_IPV6) - return ace_ipv6_enabled == -1 ? - ::ip_check (ace_ipv6_enabled, PF_INET6) : - ace_ipv6_enabled; -#else /* ACE_HAS_IPV6 */ - return 0; -#endif /* !ACE_HAS_IPV6 */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Sock_Connect.h b/deps/acelite/ace/Sock_Connect.h deleted file mode 100644 index 540111474..000000000 --- a/deps/acelite/ace/Sock_Connect.h +++ /dev/null @@ -1,105 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Sock_Connect.h - * - * @author Priyanka Gontla - * @author Based on code that existed formerly in ACE.h. - */ -//========================================================================== - -#ifndef ACE_SOCK_CONNECT_H -#define ACE_SOCK_CONNECT_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Basic_Types.h" -#include "ace/os_include/netinet/os_in.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward Declarations -class ACE_INET_Addr; - -namespace ACE -{ - // = Socket connection establishment calls. - - /// Bind a new unused port to @a handle. - extern ACE_Export int bind_port (ACE_HANDLE handle, - ACE_UINT32 ip_addr = INADDR_ANY, - int address_family = AF_UNSPEC); - - /** - * Get our broadcast address based on our @a host_addr. If - * @a hostname is non-0 we'll use it to determine our IP address. If - * @a handle is not ACE_INVALID_HANDLE then we'll use this to - * determine our broadcast address, otherwise we'll have to create a - * socket internally (and free it). Returns -1 on failure and 0 on - * success. - */ - extern ACE_Export int get_bcast_addr ( - ACE_UINT32 &bcast_addr, - const ACE_TCHAR *hostname = 0, - ACE_UINT32 host_addr = 0, - ACE_HANDLE handle = ACE_INVALID_HANDLE); - - /// Get fully qualified host/domain name. - extern ACE_Export int get_fqdn (ACE_INET_Addr const & addr, - char hostname[], - size_t len); - - /** - * Return count and array of all configured IP interfaces on this - * host, rc = 0 on success (count == number of interfaces else -1). - * Caller is responsible for calling delete [] on @a addr_array. - */ - extern ACE_Export int get_ip_interfaces (size_t &count, - ACE_INET_Addr *&addr_array); - - /** - * Helper routine for get_ip_interfaces, differs by UNIX platform so - * put into own subroutine. perform some ioctls to retrieve ifconf - * list of ifreq structs. - */ - extern ACE_Export int count_interfaces (ACE_HANDLE handle, - size_t &how_many); - - /// Routine to return a handle from which @c ioctl requests can be - /// made. Caller must close the handle. - extern ACE_Export ACE_HANDLE get_handle (void); - - /// Returns @c true if IPv4 is enabled on the current host; @c false - /// if not. - /** - * This is an execution-time check. If ACE has not been compiled - * with @c ACE_HAS_IPV6, it always returns @c true. This function - * tries to create a @c PF_INET socket, returning @c true if it - * succeeds, and @c false if it fails. Caches the result so it only - gets checked once. - */ - extern ACE_Export bool ipv4_enabled (void); - - /** - * Returns 1 if IPv6 is enabled on the current host; 0 if not. - * This is an execution-time check. If ACE has not been compiled - * with ACE_HAS_IPV6, it always returns 0. If ACE_HAS_IPV6 is - * enabled, this function tries to create a PF_INET6 socket, - * returning 1 if it succeeds, and 0 if it fails. Caches the result - * so it only gets checked once. - */ - extern ACE_Export int ipv6_enabled (void); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#endif /* ACE_SOCK_CONNECT_H */ diff --git a/deps/acelite/ace/Stack_Trace.cpp b/deps/acelite/ace/Stack_Trace.cpp deleted file mode 100644 index d4be21962..000000000 --- a/deps/acelite/ace/Stack_Trace.cpp +++ /dev/null @@ -1,754 +0,0 @@ -//============================================================================= -/** - * @file Stack_Trace.cpp - * - * @brief Encapsulate string representation of stack trace. - * - * Some platform-specific areas of this code have been adapted from - * examples found elsewhere. Specifically, - * - the GLIBC stack generation uses the documented "backtrace" API - * and is adapted from examples shown in relevant documentation - * and repeated elsewhere, e.g., - * http://www.linuxselfhelp.com/gnu/glibc/html_chapter/libc_33.html - * - the Solaris stack generation is adapted from a 1995 post on - * comp.unix.solaris by Bart Smaalders, - * http://groups.google.com/group/comp.unix.solaris/browse_thread/thread/8b9f3de8be288f1c/31550f93a48231d5?lnk=gst&q=how+to+get+stack+trace+on+solaris+group:comp.unix.solaris#31550f93a48231d5 - * - VxWorks kernel-mode stack tracing is adapted from a code example - * in the VxWorks FAQ at http://www.xs4all.nl/~borkhuis/vxworks/vxw_pt5.html - * although the undocumented functions it uses are also mentioned in - * various documents available on the WindRiver support website. - * - * If you add support for a new platform, please add a bullet to the - * above list with durable references to the origins of your code. - */ -//============================================================================= - -#include "ace/Stack_Trace.h" -#include "ace/Min_Max.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_NS_stdio.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/* - This is ugly, simply because it's very platform-specific. -*/ - -const char ACE_Stack_Trace::UNSUPPORTED[] = ""; -const char ACE_Stack_Trace::UNABLE_TO_GET_TRACE[] = ""; - -ACE_Stack_Trace::ACE_Stack_Trace (ssize_t starting_frame_offset, size_t num_frames) - : buflen_(0) -{ - // cannot initialize arrays, so we must assign. - this->buf_[0] = '\0'; - this->generate_trace (starting_frame_offset, num_frames); -} - -const char* -ACE_Stack_Trace::c_str () const -{ - return &this->buf_[0]; -} - -static inline size_t -determine_starting_frame (ssize_t initial_frame, ssize_t offset) -{ - return ACE_MAX( initial_frame + offset, static_cast(0)); -} - -#if defined(ACE_FACE_SAFETY_BASE) && !defined(ACE_FACE_DEV) -void -ACE_Stack_Trace::generate_trace (ssize_t starting_frame_offset, size_t num_frames) -{ - ACE_UNUSED_ARG (starting_frame_offset); - ACE_UNUSED_ARG (num_frames); - ACE_OS::strcpy (&this->buf_[0], UNABLE_TO_GET_TRACE); -} - -#elif (defined(__GLIBC__) || defined(ACE_HAS_EXECINFO_H)) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3)) -// This is the code for glibc -# include - -void -ACE_Stack_Trace::generate_trace (ssize_t starting_frame_offset, size_t num_frames) -{ - const size_t MAX_FRAMES = 128; - const ssize_t INITIAL_FRAME = 3; - - void* stack[MAX_FRAMES]; - size_t stack_size = 0; - char** stack_syms; - - if (num_frames == 0) - num_frames = MAX_FRAMES; - - size_t starting_frame = - determine_starting_frame (INITIAL_FRAME, starting_frame_offset); - - stack_size = ::backtrace (&stack[0], sizeof(stack)/sizeof(stack[0])); - if (stack_size != 0) - { - stack_syms = ::backtrace_symbols (stack, stack_size); - - for (size_t i = starting_frame; - i < stack_size && num_frames > 0; - i++, num_frames--) - { - // this could be more efficient by remembering where we left off in buf_ - char *symp = &stack_syms[i][0]; - while (this->buflen_ < SYMBUFSIZ - 2 && *symp != '\0') - { - this->buf_[this->buflen_++] = *symp++; - } - this->buf_[this->buflen_++] = '\n'; // put a newline at the end - } - this->buf_[this->buflen_] = '\0'; // zero terminate the string - - ::free (stack_syms); - } - else - { - ACE_OS::strcpy (&this->buf_[0], UNABLE_TO_GET_TRACE); - } -} -#elif defined(VXWORKS) && !defined(__RTP__) -# include -# include // hopefully this is enough to get all the necessary #defines. - -struct ACE_Stack_Trace_stackstate -{ - ACE_Stack_Trace_stackstate (char* b, size_t& bl, size_t nf, size_t sf) - : buf(b), buflen(bl), num_frames(nf), starting_frame(sf) - { } - - char* buf; - size_t& buflen; - size_t num_frames; - size_t starting_frame; -}; - -//@TODO: Replace with a TSS-based pointer to avoid problems in multithreaded environs, -// or use a mutex to serialize access to this. -static ACE_Stack_Trace_stackstate* ACE_Stack_Trace_stateptr = 0; - -static void -ACE_Stack_Trace_Add_Frame_To_Buf (INSTR *caller, - INSTR *func, - int nargs, - ACE_VX_USR_ARG_T *args) -{ - if (ACE_Stack_Trace_stateptr == 0) - return; - - ACE_Stack_Trace_stackstate *stackstate = ACE_Stack_Trace_stateptr; - - // Decrement the num_frames and starting_frame elements, - // then see if we're ready to start or ready to finish. - --stackstate->num_frames; - --stackstate->starting_frame; - - if (stackstate->num_frames == 0 || stackstate->starting_frame > 0) - return; - - // These are references so that the structure gets updated - // in the code below. - char*& buf = stackstate->buf; - size_t& len = stackstate->buflen; - - // At some point try using symFindByValue() to lookup func (and caller?) - // to print out symbols rather than simply addresses. - - // VxWorks can pass -1 for "nargs" if there was an error - if (nargs == -1) - nargs = 0; - - len += ACE_OS::sprintf (&buf[len], "%p: %p (", caller, func); - for (int i = 0; i < nargs; ++i) - { - if (i != 0) - len += ACE_OS::sprintf (&buf[len], ", "); - len += ACE_OS::sprintf(&buf[len], "0x" ACE_VX_ARG_FORMAT, args[i]); - } - - len += ACE_OS::sprintf(&buf[len], ")\n"); -} - -void -ACE_Stack_Trace::generate_trace (ssize_t starting_frame_offset, - size_t num_frames) -{ - const size_t MAX_FRAMES = 128; - const ssize_t INITIAL_FRAME = 3; - - if (num_frames == 0) - num_frames = MAX_FRAMES; - - size_t starting_frame = - determine_starting_frame (INITIAL_FRAME, starting_frame_offset); - - ACE_Stack_Trace_stackstate state (&this->buf_[0], this->buflen_, - num_frames, starting_frame); - - REG_SET regs; - - taskRegsGet (taskIdSelf(), ®s); - // Maybe we should take a lock here to guard stateptr? - ACE_Stack_Trace_stateptr = &state; - trcStack (®s, (FUNCPTR)ACE_Stack_Trace_Add_Frame_To_Buf, taskIdSelf ()); -} - - -#elif defined(VXWORKS) && defined(__RTP__) -# include -# include -# include - -// See memEdrLib.c in VxWorks RTP sources for an example of stack tracing. - -static STATUS ace_vx_rtp_pc_validate (INSTR *pc, TRC_OS_CTX *) -{ - return ALIGNED (pc, sizeof (INSTR)) ? OK : ERROR; -} - -void -ACE_Stack_Trace::generate_trace (ssize_t starting_frame_offset, - size_t num_frames) -{ - const size_t MAX_FRAMES = 128; - const ssize_t INITIAL_FRAME = 2; - - if (num_frames == 0) num_frames = MAX_FRAMES; - size_t starting_frame = - determine_starting_frame (INITIAL_FRAME, starting_frame_offset); - - jmp_buf regs; - setjmp (regs); - - TASK_DESC desc; - if (taskInfoGet (taskIdSelf (), &desc) == ERROR) return; - - TRC_OS_CTX osCtx; - osCtx.stackBase = desc.td_pStackBase; - osCtx.stackEnd = desc.td_pStackEnd; -#if (ACE_VXWORKS < 0x690) - osCtx.pcValidateRtn = reinterpret_cast (ace_vx_rtp_pc_validate); -#else - // reinterpret_cast causes an error - osCtx.pcValidateRtn = ace_vx_rtp_pc_validate; -#endif - - char *fp = _WRS_FRAMEP_FROM_JMP_BUF (regs); - INSTR *pc = _WRS_RET_PC_FROM_JMP_BUF (regs); - - for (size_t depth = 0; depth < num_frames + starting_frame; ++depth) - { - char *prevFp; - INSTR *prevPc; - INSTR *prevFn; - - if (trcLibFuncs.lvlInfoGet (fp, pc, &osCtx, &prevFp, &prevPc, &prevFn) - == ERROR) - { - ACE_OS::strcpy (this->buf_, UNABLE_TO_GET_TRACE); - return; - } - - if(prevPc == 0 || prevFp == 0) break; - - if (depth >= starting_frame) - { - //Hopefully a future version of VxWorks will have a system call - //for an RTP to query its own symbols, but this is not possible now. - //An enhancement request has been filed under WIND00123307. - const char *fnName = "(no symbols)"; - - static const int N_ARGS = 12; - ACE_VX_USR_ARG_T buf[N_ARGS]; - ACE_VX_USR_ARG_T *pArgs = 0; - int numArgs = - trcLibFuncs.lvlArgsGet (prevPc, prevFn, prevFp, - buf, N_ARGS, &pArgs); - - // VxWorks can return -1 for "numArgs" if there was an error - if (numArgs == -1) numArgs = 0; - - size_t len = ACE_OS::strlen (this->buf_); - size_t space = SYMBUFSIZ - len - 1; - char *cursor = this->buf_ + len; - size_t written = ACE_OS::snprintf (cursor, space, "%p %s", - prevFn, fnName); - cursor += written; - space -= written; - - if (space < 1) return; //no point in logging when we're out of buffer - for (int arg = 0; numArgs != -1 && pArgs && arg < numArgs; ++arg) - { - if (arg == 0) *cursor++ = '(', --space; - written = ACE_OS::snprintf (cursor, space, - (arg < numArgs - 1) ? - ACE_VX_ARG_FORMAT ", " : - ACE_VX_ARG_FORMAT, - pArgs[arg]); - cursor += written; - space -= written; - if (space && arg == numArgs - 1) *cursor++ = ')', --space; - } - if (space) *cursor++ = '\n', --space; - *cursor++ = 0; //we saved space for the null terminator - } - - fp = prevFp; - pc = prevPc; - } -} - -#elif defined(sun) -/* - * walks up call stack, printing library:routine+offset for each routine - */ - -# include -# include -# include -# include -# include -# define ACE_STACK_TRACE_BIAS 0 - -# if defined(sparc) || defined(__sparc) -# define ACE_STACK_TRACE_FLUSHWIN() asm("ta 3"); -# define ACE_STACK_TRACE_FRAME_PTR_INDEX 1 -# define ACE_STACK_TRACE_SKIP_FRAMES 0 -# if defined(__sparcv9) -# undef ACE_STACK_TRACE_BIAS -# define ACE_STACK_TRACE_BIAS 2047 -# endif -# endif - -# if defined(i386) || defined(__i386) -# define ACE_STACK_TRACE_FLUSHWIN() -# define ACE_STACK_TRACE_FRAME_PTR_INDEX 3 -# define ACE_STACK_TRACE_SKIP_FRAMES 0 -# endif - -# if defined(__amd64) || defined(__x86_64) -# define ACE_STACK_TRACE_FLUSHWIN() -# define ACE_STACK_TRACE_FRAME_PTR_INDEX 5 -# define ACE_STACK_TRACE_SKIP_FRAMES 0 -# endif - -# if defined(ppc) || defined(__ppc) -# define ACE_STACK_TRACE_FLUSHWIN() -# define ACE_STACK_TRACE_FRAME_PTR_INDEX 0 -# define ACE_STACK_TRACE_SKIP_FRAMES 2 -# endif - -static frame* -cs_frame_adjust(frame* sp) -{ - unsigned char* sp_byte = (unsigned char*)sp; - sp_byte += ACE_STACK_TRACE_BIAS; - return (frame*) sp_byte; -} - -/* - this function walks up call stack, calling user-supplied - function once for each stack frame, passing the pc and the user-supplied - usrarg as the argument. - */ - -static int -cs_operate(int (*func)(void *, void *), void * usrarg, - size_t starting_frame, size_t num_frames_arg) -{ - ACE_STACK_TRACE_FLUSHWIN(); - - jmp_buf env; - setjmp(env); - frame* sp = cs_frame_adjust((frame*) env[ACE_STACK_TRACE_FRAME_PTR_INDEX]); - - // make a copy of num_frames_arg to eliminate the following warning on some - // solaris platforms: - // Stack_Trace.cpp:318: warning: argument `size_t num_frames' might be clobbered by `longjmp' or `vfork' - size_t num_frames = num_frames_arg; - - // I would like to use ACE_MAX below rather than ?:, but - // I get linker relocation errors such as the following when - // I use it: - // ld: fatal: relocation error: file: .shobj/Stack_Trace.o section: - // .rela.debug_line symbol: : relocation against a discarded symbol, - // symbol is part of discarded section: - // .text%const __type_0&ace_max(const __type_0&,const __type_0&) - // - const size_t starting_skip = starting_frame - 1; -#if ACE_STACK_TRACE_SKIP_FRAMES == 0 - size_t skip_frames = starting_skip; -#else - size_t skip_frames = - ACE_STACK_TRACE_SKIP_FRAMES > starting_skip ? - ACE_STACK_TRACE_SKIP_FRAMES : starting_skip; -#endif /* ACE_STACK_TRACE_SKIP_FRAMES == 0 */ - size_t i; - for (i = 0; i < skip_frames && sp; ++i) - { - sp = cs_frame_adjust((frame*) sp->fr_savfp); - } - - i = 0; - - while ( sp - && sp->fr_savpc - && ++i - && --num_frames - && (*func)((void*)sp->fr_savpc, usrarg)) - { - sp = cs_frame_adjust((frame*) sp->fr_savfp); - } - - return(i); -} - -static int -add_frame_to_buf (void* pc, void* usrarg) -{ - char* buf = (char*)usrarg; - Dl_info info; - const char* func = "??"; - const char* lib = "??"; - - if(dladdr(pc, & info) != 0) - { - lib = (const char *) info.dli_fname; - func = (const char *) info.dli_sname; - } - - (void) ACE_OS::snprintf(buf, - ACE_Stack_Trace::SYMBUFSIZ, - "%s%s:%s+0x%x\n", - buf, - lib, - func, - //@@ Should the arithmetic on the following - //line be done with two void* ptrs? The result - //would be ptrdiff_t, and what is the correct - //sprintf() conversion character for that? - (size_t)pc - (size_t)info.dli_saddr); - - return(1); -} - -void -ACE_Stack_Trace::generate_trace (ssize_t starting_frame_offset, - size_t num_frames) -{ - const size_t MAX_FRAMES = 128; - const ssize_t INITIAL_FRAME = 3; - - if (num_frames == 0) - num_frames = MAX_FRAMES; - - size_t starting_frame = - determine_starting_frame (INITIAL_FRAME, starting_frame_offset); - - cs_operate (&add_frame_to_buf, &this->buf_[0], starting_frame, num_frames); -} - -#elif defined(ACE_WIN64) && (_WIN32_WINNT <= _WIN32_WINNT_WIN2K) -# if defined(_MSC_VER) -# define STRING2(X) #X -# define STRING(X) STRING2(X) -# pragma message (__FILE__ "(" STRING(__LINE__) ") : warning: stack traces"\ - " can't be generated on 64-bit Windows when _WIN32_WINNT is less than "\ - "0x501.") -# undef STRING -# undef STRING2 -# endif /*_MSC_VER*/ -void -ACE_Stack_Trace::generate_trace (ssize_t, size_t) -{ - ACE_OS::strcpy (&this->buf_[0], ""); -} - -#elif defined(ACE_WIN32) && !defined(ACE_HAS_WINCE) && !defined (__MINGW32__) \ - && !defined(__BORLANDC__) -# include -# include - -# define MAXTEXT 5000 -# define SYMSIZE 100 - -//@TODO: Test with WCHAR -//@TODO: Need a common CriticalSection since dbghelp is not thread-safe - -typedef struct _dbghelp_functions -{ - HMODULE hMod; //our handle to dbghelp.dll - - //these already have typedefs in DbgHelp.h - DWORD64 (WINAPI *SymGetModuleBase64) (HANDLE hProc, DWORD64 dwAddr); - PVOID (WINAPI *SymFunctionTableAccess64) (HANDLE hProc, DWORD64 AddrBase); - - typedef BOOL (WINAPI *SymFromAddr_t) - (HANDLE hProc, DWORD64 Addr, PDWORD64 Disp, PSYMBOL_INFO Symbol); - SymFromAddr_t SymFromAddr; - - typedef BOOL (WINAPI *SymGetLineFromAddr64_t) (HANDLE hProc, DWORD64 dwAddr, - PDWORD pdwDisplacement, - PIMAGEHLP_LINE64 Line); - SymGetLineFromAddr64_t SymGetLineFromAddr64; - - typedef DWORD (WINAPI *SymSetOptions_t) (DWORD SymOptions); - SymSetOptions_t SymSetOptions; - - typedef DWORD (WINAPI *SymGetOptions_t) (); - SymGetOptions_t SymGetOptions; - - typedef BOOL (WINAPI *SymInitialize_t) (HANDLE hProc, PCTSTR UserSearchPath, - BOOL invasive); - SymInitialize_t SymInitialize; - - typedef BOOL - (WINAPI *StackWalk64_t) (DWORD MachineType, HANDLE hPRoc, HANDLE hThr, - LPSTACKFRAME64 StackFrame, PVOID ContextRecord, - PREAD_PROCESS_MEMORY_ROUTINE64 RMRoutine, - PFUNCTION_TABLE_ACCESS_ROUTINE64 FTARoutine, - PGET_MODULE_BASE_ROUTINE64 GMBRoutine, - PTRANSLATE_ADDRESS_ROUTINE64 TranslateAddress); - StackWalk64_t StackWalk64; - - typedef BOOL (WINAPI *SymCleanup_t) (HANDLE hProc); - SymCleanup_t SymCleanup; -} dbghelp_functions; - - -# pragma warning (push) -# pragma warning (disable:4706) -static bool load_dbghelp_library_if_needed (dbghelp_functions *pDbg) -{ - //@TODO: See codeproject's StackWalker.cpp for the list of locations to - //search so we get the "enhanced" dbghelp if the user has it but it is not - //first on the path. - if (!(pDbg->hMod = ACE_TEXT_LoadLibrary (ACE_TEXT ("Dbghelp")))) - return false; - - //@TODO: Cache this so we don't have to re-link every time. When to unload? - -# define LINK(TYPE, NAME) (pDbg->NAME = \ - (TYPE) GetProcAddress (pDbg->hMod, #NAME)) -# define LINK_T(NAME) LINK (dbghelp_functions::NAME##_t, NAME) - return LINK (PGET_MODULE_BASE_ROUTINE64, SymGetModuleBase64) - && LINK (PFUNCTION_TABLE_ACCESS_ROUTINE64, SymFunctionTableAccess64) - && LINK_T (SymFromAddr) && LINK_T (SymGetLineFromAddr64) - && LINK_T (SymSetOptions)&& LINK_T (SymGetOptions) - && LINK_T (SymInitialize) && LINK_T (StackWalk64) && LINK_T (SymCleanup); -# undef LINK -# undef LINK_T -} -# pragma warning (pop) - - -struct frame_state { - STACKFRAME64 sf; - PSYMBOL_INFO pSym; - dbghelp_functions *pDbg; -}; - -static int -add_frame_to_buf (struct frame_state const *fs, void *usrarg) -{ - if (fs == 0 || usrarg == 0) - return -1; - - char *buf = static_cast (usrarg); - - DWORD64 disp; - DWORD64 dwModBase = fs->pDbg->SymGetModuleBase64 (GetCurrentProcess (), - fs->sf.AddrPC.Offset); - if (fs->pDbg->SymFromAddr (GetCurrentProcess (), - fs->sf.AddrPC.Offset, &disp, fs->pSym)) - { - IMAGEHLP_LINE64 line = {sizeof (IMAGEHLP_LINE64)}; - DWORD lineDisp; - if (fs->pDbg->SymGetLineFromAddr64 (GetCurrentProcess (), - fs->sf.AddrPC.Offset, - &lineDisp, &line)) - { - (void) ACE_OS::snprintf (buf, ACE_Stack_Trace::SYMBUFSIZ, - "%s%s() %s: %d + 0x%x\n", - buf, fs->pSym->Name, line.FileName, - line.LineNumber, lineDisp); - } - else - { - (void) ACE_OS::snprintf (buf, ACE_Stack_Trace::SYMBUFSIZ, - "%s%s()+0x%x [0x%x]\n", - buf, fs->pSym->Name, disp, - fs->sf.AddrPC.Offset - dwModBase); - } - } - else - { - (void) ACE_OS::snprintf (buf, ACE_Stack_Trace::SYMBUFSIZ, - "%s[0x%x]\n", - buf, fs->sf.AddrPC.Offset - dwModBase); - } - return 0; -} - -static void emptyStack () { } - -#if defined (_MSC_VER) -# pragma warning(push) -// Suppress warning 4748 "/GS can not protect parameters and local -// variables from local buffer overrun because optimizations are -// disabled in function" -# pragma warning(disable: 4748) -#endif /* _MSC_VER */ - -static int -cs_operate(int (*func)(struct frame_state const *, void *), void *usrarg, - size_t starting_frame, size_t num_frames) -{ - dbghelp_functions dbg; - if (!load_dbghelp_library_if_needed (&dbg)) - { - ACE_OS::strcpy (static_cast (usrarg), - ""); - if (dbg.hMod) FreeLibrary (dbg.hMod); - return 1; - } - - frame_state fs; - ZeroMemory (&fs.sf, sizeof (fs.sf)); - fs.pDbg = &dbg; - emptyStack (); //Not sure what this should do, Chad? - - CONTEXT c; - ZeroMemory (&c, sizeof (CONTEXT)); - c.ContextFlags = CONTEXT_FULL; - -# if defined (_M_IX86) - DWORD machine = IMAGE_FILE_MACHINE_I386; - __asm { - call x - x: pop eax - mov c.Eip, eax - mov c.Ebp, ebp - mov c.Esp, esp - } - fs.sf.AddrPC.Offset = c.Eip; - fs.sf.AddrStack.Offset = c.Esp; - fs.sf.AddrFrame.Offset = c.Ebp; - fs.sf.AddrPC.Mode = AddrModeFlat; - fs.sf.AddrStack.Mode = AddrModeFlat; - fs.sf.AddrFrame.Mode = AddrModeFlat; -# elif defined (_M_X64) - DWORD machine = IMAGE_FILE_MACHINE_AMD64; - RtlCaptureContext (&c); - fs.sf.AddrPC.Offset = c.Rip; - fs.sf.AddrFrame.Offset = c.Rsp; //should be Rbp or Rdi instead? - fs.sf.AddrStack.Offset = c.Rsp; - fs.sf.AddrPC.Mode = AddrModeFlat; - fs.sf.AddrFrame.Mode = AddrModeFlat; - fs.sf.AddrStack.Mode = AddrModeFlat; -# elif defined (_M_IA64) - DWORD machine = IMAGE_FILE_MACHINE_IA64; - RtlCaptureContext (&c); - fs.sf.AddrPC.Offset = c.StIIP; - fs.sf.AddrFrame.Offset = c.RsBSP; - fs.sf.AddrBStore.Offset = c.RsBSP; - fs.sf.AddrStack.Offset = c.IntSp; - fs.sf.AddrPC.Mode = AddrModeFlat; - fs.sf.AddrFrame.Mode = AddrModeFlat; - fs.sf.AddrBStore.Mode = AddrModeFlat; - fs.sf.AddrStack.Mode = AddrModeFlat; -# elif defined (_M_ARM) - DWORD machine = IMAGE_FILE_MACHINE_ARM; - fs.sf.AddrPC.Offset = c.Pc; - fs.sf.AddrFrame.Offset = c.R11; - fs.sf.AddrStack.Offset = c.Sp; - fs.sf.AddrPC.Mode = AddrModeFlat; - fs.sf.AddrFrame.Mode = AddrModeFlat; - fs.sf.AddrStack.Mode = AddrModeFlat; -# elif defined (_M_ARM64) - DWORD machine = IMAGE_FILE_MACHINE_ARM64; - fs.sf.AddrPC.Offset = c.Pc; - fs.sf.AddrFrame.Offset = c.Fp; - fs.sf.AddrStack.Offset = c.Sp; - fs.sf.AddrPC.Mode = AddrModeFlat; - fs.sf.AddrFrame.Mode = AddrModeFlat; - fs.sf.AddrStack.Mode = AddrModeFlat; -# endif - - fs.pSym = (PSYMBOL_INFO) GlobalAlloc (GMEM_FIXED, - sizeof (SYMBOL_INFO) + - sizeof (ACE_TCHAR) * (SYMSIZE - 1)); - fs.pSym->SizeOfStruct = sizeof (SYMBOL_INFO); - fs.pSym->MaxNameLen = SYMSIZE * sizeof (ACE_TCHAR); - dbg.SymSetOptions (SYMOPT_DEFERRED_LOADS | SYMOPT_LOAD_LINES - | SYMOPT_FAIL_CRITICAL_ERRORS | dbg.SymGetOptions ()); - dbg.SymInitialize (GetCurrentProcess (), 0, true); - //What does the "true" parameter mean when tracing the current process? - - for (size_t current_frame = 0; current_frame < num_frames + starting_frame; - ++current_frame) - { - BOOL ok = dbg.StackWalk64 (machine, - GetCurrentProcess (), - GetCurrentThread (), - &fs.sf, &c, 0, - dbg.SymFunctionTableAccess64, - dbg.SymGetModuleBase64, 0); - if (!ok || fs.sf.AddrFrame.Offset == 0) - break; - - if (current_frame < starting_frame) - continue; - - func (&fs, usrarg); - } - - dbg.SymCleanup (GetCurrentProcess ()); - GlobalFree (fs.pSym); - FreeLibrary (dbg.hMod); - - return 0; -} - -#if defined (_MSC_VER) -// Restore the warning state to what it was before entry. -# pragma warning(pop) -#endif /* _MSC_VER */ - -void -ACE_Stack_Trace::generate_trace (ssize_t starting_frame_offset, - size_t num_frames) -{ - const size_t MAX_FRAMES = 128; - const ssize_t INITIAL_FRAME = 3; - - if (num_frames == 0) - num_frames = MAX_FRAMES; - - size_t starting_frame = - determine_starting_frame (INITIAL_FRAME, starting_frame_offset); - - cs_operate (&add_frame_to_buf, &this->buf_[0], starting_frame, num_frames); -} - -#else // Unsupported platform -void -ACE_Stack_Trace::generate_trace (ssize_t, size_t) -{ -// Call determine_starting_frame() on HP aCC build to resolve declared -// method never referenced warning. -#if defined (__HP_aCC) - size_t starting_frame = determine_starting_frame (0, 0); -#endif - - ACE_OS::strcpy (&this->buf_[0], UNSUPPORTED); -} -#endif - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Stack_Trace.h b/deps/acelite/ace/Stack_Trace.h deleted file mode 100644 index 14cdcc012..000000000 --- a/deps/acelite/ace/Stack_Trace.h +++ /dev/null @@ -1,109 +0,0 @@ -// -*- C++ -*- -//============================================================================= -/** - * @file Stack_Trace.h - * - * @author Chris Cleeland (cleeland.ociweb.com) - */ -//============================================================================= - -#ifndef ACE_STACK_TRACE_H -#define ACE_STACK_TRACE_H - -#include /**/ "ace/pre.h" - -#include "ace/ACE_export.h" -#include "ace/Basic_Types.h" - -# if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -# endif /* ACE_LACKS_PRAGMA_ONCE */ - -# ifndef ACE_STACK_TRACE_SYMBUFSIZ -# define ACE_STACK_TRACE_SYMBUFSIZ 4096 -# endif - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Stack_Trace - * - * @brief Encapsulate a string representation of a stack trace on supported platforms. - * Stack traces for code built with optimize=1 (or "Release" configs on Visual - * Studio) may be misleading (missng frames) due to inlining performed by the - * compiler, which is indepenent of the inline=0 / inline=1 build option and - * the __ACE_INLINE__ / ACE_NO_INLINE macros. - * - * A new conversion character, the question mark, was added to ACE_Log_Msg for stack - * trace logging. The %? conversion character was added as a convenience so that users - * need not instantiate an ACE_Stack_Trace instance solely for the purpose of printing - * it in an ACE logging message. The following are functionally equivalent: - * - * \code - * ACELIB_DEBUG((LM_DEBUG, "%?")); - * - * ACE_Stack_Trace st; - * ACELIB_DEBUG ((LM_DEBUG, "%C", st.c_str() )); - * \endcode - * - * These usage examples were shown in $ACE_ROOT/tests/Stack_Trace_Test.cpp. - * - * @note The stack trace functionality was currently supported on platforms: - * - Any platform using glibc as its runtime library, or where ACE_HAS_EXECINFO_H is defined - * (this covers Linux and Mac) and gcc version >= 3.3. - * - VxWorks, both kernel and RTP - * - Solaris - * - Windows 32 and 64 bit (Visual C++, excluding WinCE/mobile) - * - * @note Since stack trace buffer size has limitation(@c ACE_STACK_TRACE_SYMBUFSIZ), you will not - * get a complete stack trace if @c ACE_STACK_TRACE_SYMBUFSIZ value is less than actual stack - * trace data length. To get a complete stack trace, you need set @c ACE_STACK_TRACE_SYMBUFSIZ - * with a larger value that is enough for the stack trace data in your @c config.h file - * and rebuild ACE. - * - * @note Using ACE logging mechanism (%?) to log the stack trace also has ACE_MAXLOGMSGLEN size limitation. - * To get a complete stack trace, you could use different output method. Following is an example. - * - * \code - * ACE_Stack_Trace st; - * ACE_OS::printf("at [%s]\n", st.c_str()); - * \endcode - */ -class ACE_Export ACE_Stack_Trace -{ -public: - /** - * @brief Grab a snapshot of the current stack trace and hold it for later use. - * - * @param starting_frame_offset offset into the array of frames to start printing; 0 is the - * platform-specific offset for the first frame, positive numbers give less frames, negative give - * more frames - * @param num_frames the number of stack frames to include (0 indicates platform-specific maximum) - * - */ - explicit ACE_Stack_Trace (ssize_t starting_frame_offset = 0, size_t num_frames = 0); - - /** - * @brief Return buffer as a C-style string. - * @return C-style string with string representation of stack trace. - * @note Lifecycle of string follows lifecycle of ACE_Stack_Trace instance. - */ - const char* c_str() const; - - static const size_t SYMBUFSIZ = ACE_STACK_TRACE_SYMBUFSIZ; - -private: - char buf_[SYMBUFSIZ]; - size_t buflen_; - - static const char UNSUPPORTED[]; - static const char UNABLE_TO_GET_TRACE[]; - - void generate_trace (ssize_t starting_frame_offset, size_t num_frames); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" -#endif /* ACE_STACK_TRACE_H */ - diff --git a/deps/acelite/ace/Static_Object_Lock.h b/deps/acelite/ace/Static_Object_Lock.h deleted file mode 100644 index fc167062f..000000000 --- a/deps/acelite/ace/Static_Object_Lock.h +++ /dev/null @@ -1,55 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Static_Object_Lock.h - * - * @author David L. Levine - * @author Matthias Kerkhoff - * @author Per Andersson - */ -//============================================================================= - -#ifndef ACE_STATIC_OBJECT_LOCK_H -#define ACE_STATIC_OBJECT_LOCK_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if defined (ACE_HAS_THREADS) - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Recursive_Thread_Mutex; - -/** - * @class ACE_Static_Object_Lock - * - * @brief Provide an interface to access a global lock. - * - * This class is used to serialize the creation of static - * singleton objects. It really isn't needed any more, because - * anyone can access ACE_STATIC_OBJECT_LOCK directly. But, it - * is retained for backward compatibility. - */ -class ACE_Export ACE_Static_Object_Lock -{ -public: - /// Static lock access point. - static ACE_Recursive_Thread_Mutex *instance (void); - - /// For use only by ACE_Object_Manager to clean up lock if it - /// what dynamically allocated. - static void cleanup_lock (void); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_THREADS */ - -#include /**/ "ace/post.h" -#endif /* ACE_STATIC_OBJECT_LOCK_H */ diff --git a/deps/acelite/ace/Stats.cpp b/deps/acelite/ace/Stats.cpp deleted file mode 100644 index b47c4857f..000000000 --- a/deps/acelite/ace/Stats.cpp +++ /dev/null @@ -1,413 +0,0 @@ -#include "ace/Stats.h" - -#if !defined (__ACE_INLINE__) -# include "ace/Stats.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/OS_NS_stdio.h" -#include "ace/OS_NS_string.h" - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_UINT32 -ACE_Stats_Value::fractional_field (void) const -{ - if (precision () == 0) - { - return 1; - } - else - { - ACE_UINT32 field = 10; - for (u_int i = 0; i < precision () - 1; ++i) - { - field *= 10; - } - - return field; - } -} - -int -ACE_Stats::sample (const ACE_INT32 value) -{ - if (samples_.enqueue_tail (value) == 0) - { - ++number_of_samples_; - if (number_of_samples_ == 0) - { - // That's a lot of samples :-) - overflow_ = EFAULT; - return -1; - } - - if (value < min_) - min_ = value; - - if (value > max_) - max_ = value; - - return 0; - } - else - { - // Probably failed due to running out of memory when trying to - // enqueue the new value. - overflow_ = errno; - return -1; - } -} - -void -ACE_Stats::mean (ACE_Stats_Value &m, - const ACE_UINT32 scale_factor) -{ - if (number_of_samples_ > 0) - { - const ACE_UINT64 ACE_STATS_INTERNAL_OFFSET = - ACE_UINT64_LITERAL (0x100000000); - - ACE_UINT64 sum = ACE_STATS_INTERNAL_OFFSET; - ACE_Unbounded_Queue_Iterator i (samples_); - while (! i.done ()) - { - ACE_INT32 *sample; - if (i.next (sample)) - { - sum += *sample; - i.advance (); - } - } - - // sum_ was initialized with ACE_STATS_INTERNAL_OFFSET, so - // subtract that off here. - quotient (sum - ACE_STATS_INTERNAL_OFFSET, - number_of_samples_ * scale_factor, - m); - } - else - { - m.whole (0); - m.fractional (0); - } -} - -int -ACE_Stats::std_dev (ACE_Stats_Value &std_dev, - const ACE_UINT32 scale_factor) -{ - if (number_of_samples_ <= 1) - { - std_dev.whole (0); - std_dev.fractional (0); - } - else - { - const ACE_UINT32 field = std_dev.fractional_field (); - - // The sample standard deviation is: - // - // sqrt (sum (sample_i - mean)^2 / (number_of_samples_ - 1)) - - ACE_UINT64 mean_scaled; - // Calculate the mean, scaled, so that we don't lose its - // precision. - ACE_Stats_Value avg (std_dev.precision ()); - mean (avg, 1u); - avg.scaled_value (mean_scaled); - - // Calculate the summation term, of squared differences from the - // mean. - ACE_UINT64 sum_of_squares = 0; - ACE_Unbounded_Queue_Iterator i (samples_); - while (! i.done ()) - { - ACE_INT32 *sample; - if (i.next (sample)) - { - const ACE_UINT64 original_sum_of_squares = sum_of_squares; - - // Scale up by field width so that we don't lose the - // precision of the mean. Carefully . . . - const ACE_UINT64 product (*sample * field); - - ACE_UINT64 difference; - // NOTE: please do not reformat this code! It // - // works with the Diab compiler the way it is! // - if (product >= mean_scaled) // - { // - difference = product - mean_scaled; // - } // - else // - { // - difference = mean_scaled - product; // - } // - // NOTE: please do not reformat this code! It // - // works with the Diab compiler the way it is! // - - // Square using 64-bit arithmetic. - sum_of_squares += difference * ACE_U64_TO_U32 (difference); - i.advance (); - - if (sum_of_squares < original_sum_of_squares) - { - overflow_ = ENOSPC; - return -1; - } - } - } - - // Divide the summation by (number_of_samples_ - 1), to get the - // variance. In addition, scale the variance down to undo the - // mean scaling above. Otherwise, it can get too big. - ACE_Stats_Value variance (std_dev.precision ()); - quotient (sum_of_squares, - (number_of_samples_ - 1) * field * field, - variance); - - // Take the square root of the variance to get the standard - // deviation. First, scale up . . . - ACE_UINT64 scaled_variance; - variance.scaled_value (scaled_variance); - - // And scale up, once more, because we'll be taking the square - // root. - scaled_variance *= field; - ACE_Stats_Value unscaled_standard_deviation (std_dev.precision ()); - square_root (scaled_variance, - unscaled_standard_deviation); - - // Unscale. - quotient (unscaled_standard_deviation, - scale_factor * field, - std_dev); - } - - return 0; -} - - -void -ACE_Stats::reset (void) -{ - overflow_ = 0u; - number_of_samples_ = 0u; - min_ = 0x7FFFFFFF; - max_ = -0x8000 * 0x10000; - samples_.reset (); -} - -int -ACE_Stats::print_summary (const u_int precision, - const ACE_UINT32 scale_factor, - FILE *file) const -{ - ACE_TCHAR mean_string [128]; - ACE_TCHAR std_dev_string [128]; - ACE_TCHAR min_string [128]; - ACE_TCHAR max_string [128]; - int success = 0; - - for (int tmp_precision = precision; - ! overflow_ && ! success && tmp_precision >= 0; - --tmp_precision) - { - // Build a format string, in case the C library doesn't support %*u. - ACE_TCHAR format[32]; - if (tmp_precision == 0) - ACE_OS::snprintf (format, 32, ACE_TEXT ("%%%d"), tmp_precision); - else - ACE_OS::snprintf (format, 32, ACE_TEXT ("%%d.%%0%du"), tmp_precision); - - ACE_Stats_Value u (tmp_precision); - ((ACE_Stats *) this)->mean (u, scale_factor); - ACE_OS::snprintf (mean_string, 128, format, u.whole (), u.fractional ()); - - ACE_Stats_Value sd (tmp_precision); - if (((ACE_Stats *) this)->std_dev (sd, scale_factor)) - { - success = 0; - continue; - } - else - { - success = 1; - } - ACE_OS::snprintf (std_dev_string, 128, format, sd.whole (), - sd.fractional ()); - - ACE_Stats_Value minimum (tmp_precision), maximum (tmp_precision); - if (min_ != 0) - { - const ACE_UINT64 m (min_); - quotient (m, scale_factor, minimum); - } - if (max_ != 0) - { - const ACE_UINT64 m (max_); - quotient (m, scale_factor, maximum); - } - ACE_OS::snprintf (min_string, 128, format, - minimum.whole (), minimum.fractional ()); - ACE_OS::snprintf (max_string, 128, format, - maximum.whole (), maximum.fractional ()); - } - - if (success == 1) - { - ACE_OS::fprintf (file, ACE_TEXT ("samples: %u (%s - %s); mean: ") - ACE_TEXT ("%s; std dev: %s\n"), - samples (), min_string, max_string, - mean_string, std_dev_string); - return 0; - } - else - { - ACE_OS::fprintf (file, - ACE_TEXT ("ACE_Stats::print_summary: OVERFLOW: %s\n"), - ACE_OS::strerror (overflow_)); - - return -1; - } -} - -void -ACE_Stats::quotient (const ACE_UINT64 dividend, - const ACE_UINT32 divisor, - ACE_Stats_Value "ient) -{ - // The whole part of the division comes from simple integer division. - quotient.whole (static_cast (divisor == 0 - ? 0 : dividend / divisor)); - - if (quotient.precision () > 0 || divisor == 0) - { - const ACE_UINT32 field = quotient.fractional_field (); - - // Fractional = (dividend % divisor) * 10^precision / divisor - - // It would be nice to add round-up term: - // Fractional = (dividend % divisor) * 10^precision / divisor + - // 10^precision/2 / 10^precision - // = ((dividend % divisor) * 10^precision + divisor) / - // divisor - quotient.fractional (static_cast ( - dividend % divisor * field / divisor)); - } - else - { - // No fractional portion is requested, so don't bother - // calculating it. - quotient.fractional (0); - } -} - -void -ACE_Stats::quotient (const ACE_Stats_Value ÷nd, - const ACE_UINT32 divisor, - ACE_Stats_Value "ient) -{ - // The whole part of the division comes from simple integer division. - quotient.whole (divisor == 0 ? 0 : dividend.whole () / divisor); - - if (quotient.precision () > 0 || divisor == 0) - { - const ACE_UINT32 field = quotient.fractional_field (); - - // Fractional = (dividend % divisor) * 10^precision / divisor. - quotient.fractional (dividend.whole () % divisor * field / divisor + - dividend.fractional () / divisor); - } - else - { - // No fractional portion is requested, so don't bother - // calculating it. - quotient.fractional (0); - } -} - -void -ACE_Stats::square_root (const ACE_UINT64 n, - ACE_Stats_Value &square_root) -{ - ACE_UINT32 floor = 0; - ACE_UINT32 ceiling = 0xFFFFFFFFu; - ACE_UINT32 mid = 0; - u_int i; - - // The maximum number of iterations is log_2 (2^64) == 64. - for (i = 0; i < 64; ++i) - { - mid = (ceiling - floor) / 2 + floor; - if (floor == mid) - // Can't divide the interval any further. - break; - else - { - // Multiply carefully to avoid overflow. - ACE_UINT64 mid_squared = mid; mid_squared *= mid; - if (mid_squared == n) - break; - else if (mid_squared < n) - floor = mid; - else - ceiling = mid; - } - } - - square_root.whole (mid); - ACE_UINT64 mid_squared = mid; mid_squared *= mid; - - if (square_root.precision () && mid_squared < n) - { - // (mid * 10^precision + fractional)^2 == - // n^2 * 10^(precision * 2) - - const ACE_UINT32 field = square_root.fractional_field (); - - floor = 0; - ceiling = field; - mid = 0; - - // Do the 64-bit arithmetic carefully to avoid overflow. - ACE_UINT64 target = n; - target *= field; - target *= field; - - ACE_UINT64 difference = 0; - - for (i = 0; i < square_root.precision (); ++i) - { - mid = (ceiling - floor) / 2 + floor; - - ACE_UINT64 current = square_root.whole () * field + mid; - current *= square_root.whole () * field + mid; - - if (floor == mid) - { - difference = target - current; - break; - } - else if (current <= target) - floor = mid; - else - ceiling = mid; - } - - // Check to see if the fractional part should be one greater. - ACE_UINT64 next = square_root.whole () * field + mid + 1; - next *= square_root.whole () * field + mid + 1; - - square_root.fractional (next - target < difference ? mid + 1 : mid); - } - else - { - // No fractional portion is requested, so don't bother - // calculating it. - square_root.fractional (0); - } -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Stats.h b/deps/acelite/ace/Stats.h deleted file mode 100644 index e3f16fdd5..000000000 --- a/deps/acelite/ace/Stats.h +++ /dev/null @@ -1,226 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Stats.h - * - * @author David L. Levine - */ -//========================================================================== - - -#ifndef ACE_STATS_H -#define ACE_STATS_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Unbounded_Queue.h" -#include "ace/Log_Category.h" -#include "ace/Basic_Stats.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Stats_Value - * - * @brief Helper class for ACE_Stats. - * - * Container struct for 64-bit signed quantity and its - * precision. It would be nicer to use a fixed-point class, but - * this is sufficient. Users typically don't need to use this - * class directly; see ACE_Stats below. - */ -class ACE_Export ACE_Stats_Value -{ -public: - /** - * Constructor, which requires precision in terms of number of - * decimal digits. The more variation in the data, and the greater - * the data values, the smaller the precision must be to avoid - * overflow in the standard deviation calculation. 3 might be a - * good value, or maybe 4. 5 will probably be too large for - * non-trivial data sets. - */ - ACE_Stats_Value (const u_int precision); - - /// Accessor for precision. - u_int precision (void) const; - - /// Set the whole_ field. - void whole (const ACE_UINT32); - - /// Accessor for the whole_ field. - ACE_UINT32 whole (void) const; - - /// Set the fractional_ field. - void fractional (const ACE_UINT32); - - /// Accessor for the fractional_ field. - ACE_UINT32 fractional (void) const; - - /// Calculates the maximum value of the fractional portion, given its - /// precision. - ACE_UINT32 fractional_field (void) const; - - /** - * Access the value as an _unsigned_ 64 bit quantity. It scales the - * value up by {precision} decimal digits, so that no precision will - * be lost. It assumes that {whole_} is >= 0. - */ - void scaled_value (ACE_UINT64 &) const; - - /// Print to stdout. - void dump (void) const; - -private: - - ACE_Stats_Value (void) {} - -private: - /// The integer portion of the value. - ACE_UINT32 whole_; - - /// The fractional portion of the value. - ACE_UINT32 fractional_; - - /** - * The number of decimal digits of precision represented by - * {fractional_}. Not declared const, so the only way to change it - * is via the assignment operator. - */ - u_int precision_; - -}; - -/** - * @class ACE_Stats - * - * @brief Provides simple statistical analysis. - * - * Simple statistical analysis package. Prominent features are: - * -# It does not use any floating point arithmetic. - * -# It handles positive and/or negative sample values. The - * sample value type is ACE_INT32. - * -# It uses 64 bit unsigned, but not 64 bit signed, quantities - * internally. - * -# It checks for overflow of internal state. - * -# It has no static variables of other than built-in types. - * - * Example usage: - * - * @verbatim - * ACE_Stats stats; - * for (u_int i = 0; i < n; ++i) - * { - * const ACE_UINT32 sample = ...; - * stats.sample (sample); - * } - * stats.print_summary (3); - * @endverbatim - */ -class ACE_Export ACE_Stats -{ -public: - /// Default constructor. - ACE_Stats (void); - - /// Provide a new sample. Returns 0 on success, -1 if it fails due - /// to running out of memory, or to rolling over of the sample count. - int sample (const ACE_INT32 value); - - /// Access the number of samples provided so far. - ACE_UINT32 samples (void) const; - - /// Value of the minimum sample provided so far. - ACE_INT32 min_value (void) const; - - /// Value of the maximum sample provided so far. - ACE_INT32 max_value (void) const; - - /** - * Access the mean of all samples provided so far. The fractional - * part is to the specified number of digits. E.g., 3 fractional - * digits specifies that the fractional part is in thousandths. - */ - void mean (ACE_Stats_Value &mean, - const ACE_UINT32 scale_factor = 1); - - /// Access the standard deviation, whole and fractional parts. See - /// description of {mean} method for argument descriptions. - int std_dev (ACE_Stats_Value &std_dev, - const ACE_UINT32 scale_factor = 1); - - /** - * Print summary statistics. If scale_factor is not 1, then the - * results are divided by it, i.e., each of the samples is scaled - * down by it. If internal overflow is reached with the specified - * scale factor, it successively tries to reduce it. Returns -1 if - * there is overflow even with a 0 scale factor. - */ - int print_summary (const u_int precision, - const ACE_UINT32 scale_factor = 1, - FILE * -#ifdef ACE_LACKS_STDOUT - = 0 -#else - = stdout -#endif - ) const; - - /// Initialize internal state. - void reset (void); - - /// Utility division function, for ACE_UINT64 dividend. - static void quotient (const ACE_UINT64 dividend, - const ACE_UINT32 divisor, - ACE_Stats_Value "ient); - - /// Utility division function, for ACE_Stats_Value dividend. - static void quotient (const ACE_Stats_Value ÷nd, - const ACE_UINT32 divisor, - ACE_Stats_Value "ient); - - /** - * Sqrt function, which uses an oversimplified version of Newton's - * method. It's not fast, but it doesn't require floating point - * support. - */ - static void square_root (const ACE_UINT64 n, - ACE_Stats_Value &square_root); - - /// Print summary statistics to stdout. - void dump (void) const; - -protected: - /// Internal indication of whether there has been overflow. Contains - /// the errno corresponding to the cause of overflow. - u_int overflow_; - - /// Number of samples. - ACE_UINT32 number_of_samples_; - - /// Minimum sample value. - ACE_INT32 min_; - - /// Maximum sample value. - ACE_INT32 max_; - - /// The samples. - ACE_Unbounded_Queue samples_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -# include "ace/Stats.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* ! ACE_STATS_H */ diff --git a/deps/acelite/ace/Stats.inl b/deps/acelite/ace/Stats.inl deleted file mode 100644 index 2e54c1228..000000000 --- a/deps/acelite/ace/Stats.inl +++ /dev/null @@ -1,101 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Stats_Value::ACE_Stats_Value (const u_int precision) - : whole_ (0), - fractional_ (0), - precision_ (precision) -{ -} - -ACE_INLINE -u_int -ACE_Stats_Value::precision (void) const -{ - return precision_; -} - -ACE_INLINE -void -ACE_Stats_Value::whole (const ACE_UINT32 value) -{ - whole_ = value; -} - -ACE_INLINE -ACE_UINT32 -ACE_Stats_Value::whole (void) const -{ - return whole_; -} - -ACE_INLINE -void -ACE_Stats_Value::fractional (const ACE_UINT32 value) -{ - fractional_ = value; -} - -ACE_INLINE -ACE_UINT32 -ACE_Stats_Value::fractional (void) const -{ - return fractional_; -} - -ACE_INLINE -void -ACE_Stats_Value::scaled_value (ACE_UINT64 &sv) const -{ - sv = whole () * fractional_field () + fractional (); -} - -ACE_INLINE -void -ACE_Stats_Value::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("precision: %u digits; whole: %u, fractional: %u\n"), - precision_, whole_, fractional_)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_INLINE -ACE_Stats::ACE_Stats (void) -{ - reset (); -} - -ACE_INLINE -ACE_UINT32 -ACE_Stats::samples (void) const -{ - return number_of_samples_; -} - -ACE_INLINE -ACE_INT32 -ACE_Stats::min_value (void) const -{ - return min_; -} - -ACE_INLINE -ACE_INT32 -ACE_Stats::max_value (void) const -{ - return max_; -} - -ACE_INLINE -void -ACE_Stats::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - print_summary (3u); -#endif /* ACE_HAS_DUMP */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Strategies_T.cpp b/deps/acelite/ace/Strategies_T.cpp deleted file mode 100644 index 723bc1e27..000000000 --- a/deps/acelite/ace/Strategies_T.cpp +++ /dev/null @@ -1,1504 +0,0 @@ -#ifndef ACE_STRATEGIES_T_CPP -#define ACE_STRATEGIES_T_CPP - -#include "ace/Strategies_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Service_Repository.h" -#include "ace/Service_Types.h" -#include "ace/Thread_Manager.h" -#include "ace/WFMO_Reactor.h" -#include "ace/ACE.h" -#include "ace/OS_NS_dlfcn.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_Errno.h" -#include "ace/Svc_Handler.h" -#if defined (ACE_OPENVMS) -# include "ace/Lib_Find.h" -#endif - -#if !defined (__ACE_INLINE__) -#include "ace/Strategies_T.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Recycling_Strategy::~ACE_Recycling_Strategy (void) -{ -} - -template int -ACE_Recycling_Strategy::assign_recycler (SVC_HANDLER *svc_handler, - ACE_Connection_Recycling_Strategy *recycler, - const void *recycling_act) -{ - svc_handler->recycler (recycler, recycling_act); - return 0; -} - -template int -ACE_Recycling_Strategy::prepare_for_recycling (SVC_HANDLER *svc_handler) -{ - return svc_handler->recycle (); -} - -template -ACE_Singleton_Strategy::~ACE_Singleton_Strategy (void) -{ - ACE_TRACE ("ACE_Singleton_Strategy::~ACE_Singleton_Strategy"); - if (this->delete_svc_handler_) - delete this->svc_handler_; -} - -// Create a Singleton SVC_HANDLER by always returning the same -// SVC_HANDLER. - -template int -ACE_Singleton_Strategy::make_svc_handler (SVC_HANDLER *&sh) -{ - ACE_TRACE ("ACE_Singleton_Strategy::make_svc_handler"); - sh = this->svc_handler_; - return 0; -} - -template int -ACE_Singleton_Strategy::open (SVC_HANDLER *sh, - ACE_Thread_Manager *) -{ - ACE_TRACE ("ACE_Singleton_Strategy::open"); - - if (this->delete_svc_handler_) - delete this->svc_handler_; - - // If is NULL then create a new . - if (sh == 0) - { - ACE_NEW_RETURN (this->svc_handler_, - SVC_HANDLER, - -1); - this->delete_svc_handler_ = true; - } - else - { - this->svc_handler_ = sh; - this->delete_svc_handler_ = false; - } - - return 0; -} - -template int -ACE_DLL_Strategy::open (const ACE_TCHAR dll_name[], - const ACE_TCHAR factory_function[], - const ACE_TCHAR svc_name[], - ACE_Service_Repository *svc_rep, - ACE_Thread_Manager *thr_mgr) -{ - ACE_TRACE ("ACE_DLL_Strategy::open"); - this->inherited::open (thr_mgr); - ACE_OS::strcpy (this->dll_name_, dll_name); - ACE_OS::strcpy (this->factory_function_, factory_function); - ACE_OS::strcpy (this->svc_name_, svc_name); - this->svc_rep_ = svc_rep; - return 0; -} - -// Create a SVC_HANDLER by dynamically linking it from a DLL. - -template int -ACE_DLL_Strategy::make_svc_handler (SVC_HANDLER *&sh) -{ - ACE_TRACE ("ACE_DLL_Strategy::make_svc_handler"); - - // Open the shared library. - ACE_SHLIB_HANDLE handle = ACE_OS::dlopen (this->dll_name_); - - // Extract the factory function. -#if defined (ACE_OPENVMS) - SVC_HANDLER *(*factory)(void) = - (SVC_HANDLER *(*)(void)) ACE::ldsymbol (handle, - this->factory_function_); -#else - SVC_HANDLER *(*factory)(void) = - (SVC_HANDLER *(*)(void)) ACE_OS::dlsym (handle, - this->factory_function_); -#endif - - // Call the factory function to obtain the new SVC_Handler (should - // use RTTI here when it becomes available...) - SVC_HANDLER *svc_handler = 0; - - ACE_ALLOCATOR_RETURN (svc_handler, (*factory)(), -1); - - if (svc_handler != 0) - { - // Create an ACE_Service_Type containing the SVC_Handler and - // insert into this->svc_rep_; - - ACE_Service_Type_Impl *stp = 0; - ACE_NEW_RETURN (stp, - ACE_Service_Object_Type (svc_handler, - this->svc_name_), - -1); - - ACE_Service_Type *srp = 0; - - ACE_NEW_RETURN (srp, - ACE_Service_Type (this->svc_name_, - stp, - handle, - 1), - -1); - if (srp == 0) - { - delete stp; - errno = ENOMEM; - return -1; - } - - if (this->svc_rep_->insert (srp) == -1) - return -1; - // @@ Somehow, we need to deal with this->thr_mgr_... - } - - sh = svc_handler; - return 0; -} - -// Default behavior is to activate the SVC_HANDLER by calling it's -// open() method, which allows the SVC_HANDLER to determine its own -// concurrency strategy. - -template int -ACE_Concurrency_Strategy::activate_svc_handler (SVC_HANDLER *svc_handler, - void *arg) -{ - ACE_TRACE ("ACE_Concurrency_Strategy::activate_svc_handler"); - - int result = 0; - - // See if we should enable non-blocking I/O on the 's - // peer. - if (ACE_BIT_ENABLED (this->flags_, ACE_NONBLOCK) != 0) - { - if (svc_handler->peer ().enable (ACE_NONBLOCK) == -1) - result = -1; - } - // Otherwise, make sure it's disabled by default. - else if (svc_handler->peer ().disable (ACE_NONBLOCK) == -1) - result = -1; - - if (result == 0 && svc_handler->open (arg) == -1) - result = -1; - - if (result == -1) - // The connection was already made; so this close is a "normal" close - // operation. - svc_handler->close (NORMAL_CLOSE_OPERATION); - - return result; -} - -template int -ACE_Reactive_Strategy::open (ACE_Reactor *reactor, - ACE_Reactor_Mask mask, - int flags) -{ - ACE_TRACE ("ACE_Reactive_Strategy::open"); - this->reactor_ = reactor; - this->mask_ = mask; - this->flags_ = flags; - - // Must have a - if (this->reactor_ == 0) - return -1; - else - return 0; -} - -template int -ACE_Reactive_Strategy::activate_svc_handler (SVC_HANDLER *svc_handler, - void *arg) -{ - ACE_TRACE ("ACE_Reactive_Strategy::activate_svc_handler"); - - int result = 0; - - if (this->reactor_ == 0) - result = -1; - - // Register with the Reactor with the appropriate . - else if (this->reactor_->register_handler (svc_handler, this->mask_) == -1) - result = -1; - - // If the implementation of the reactor uses event associations - else if (this->reactor_->uses_event_associations ()) - { - // If we don't have non-block on, it won't work with - // WFMO_Reactor - // This maybe too harsh - // if (!ACE_BIT_ENABLED (this->flags_, ACE_NONBLOCK)) - // goto failure; - if (svc_handler->open (arg) != -1) - return 0; - else - result = -1; - } - else - // Call up to our parent to do the SVC_HANDLER initialization. - return this->inherited::activate_svc_handler (svc_handler, arg); - - if (result == -1) - // The connection was already made; so this close is a "normal" close - // operation. - svc_handler->close (NORMAL_CLOSE_OPERATION); - - return result; -} - -template int -ACE_Thread_Strategy::open (ACE_Thread_Manager *thr_mgr, - long thr_flags, - int n_threads, - int flags) -{ - ACE_TRACE ("ACE_Thread_Strategy::open"); - this->thr_mgr_ = thr_mgr; - this->n_threads_ = n_threads; - this->thr_flags_ = thr_flags; - this->flags_ = flags; - - // Must have a thread manager! - if (this->thr_mgr_ == 0) - ACELIB_ERROR_RETURN ((LM_ERROR, - ACE_TEXT ("error: must have a non-NULL thread manager\n")), - -1); - else - return 0; -} - -template int -ACE_Thread_Strategy::activate_svc_handler (SVC_HANDLER *svc_handler, - void *arg) -{ - ACE_TRACE ("ACE_Thread_Strategy::activate_svc_handler"); - // Call up to our parent to do the SVC_HANDLER initialization. - if (this->inherited::activate_svc_handler (svc_handler, - arg) == -1) - return -1; - else - // Turn the into an active object (if it isn't - // already one as a result of the first activation...) - return svc_handler->activate (this->thr_flags_, - this->n_threads_); -} - -template int -ACE_Accept_Strategy::open - (const ACE_PEER_ACCEPTOR_ADDR &local_addr, bool reuse_addr) -{ - this->reuse_addr_ = reuse_addr; - this->peer_acceptor_addr_ = local_addr; - if (this->peer_acceptor_.open (local_addr, reuse_addr) == -1) - return -1; - - // Set the peer acceptor's handle into non-blocking mode. This is a - // safe-guard against the race condition that can otherwise occur - // between the time when was interrupted. - if (ACE_Sig_Handler::sig_pending () != 0) - { - ACE_Sig_Handler::sig_pending (0); - - // This piece of code comes from the old TP_Reactor. We did not - // handle signals at all then. If we happen to handle signals - // in the TP_Reactor, we should then start worryiung about this - // - Bala 21-Aug- 01 -if 0 - // Not sure if this should be done in the TP_Reactor - // case... leave it out for now. -Steve Huston 22-Aug-00 - - // If any HANDLES in the are activated as a - // result of signals they should be dispatched since - // they may be time critical... - active_handle_count = this->any_ready (dispatch_set); -else - // active_handle_count = 0; -endif - - // Record the fact that the Reactor has dispatched a - // handle_signal() method. We need this to return the - // appropriate count. - return 1; - } - - return -1; -} -#endif // #if 0 - - -int -ACE_TP_Reactor::handle_timer_events (int & /*event_count*/, - ACE_TP_Token_Guard &guard) -{ - typedef ACE_Member_Function_Command Guard_Release; - - Guard_Release release(guard, &ACE_TP_Token_Guard::release_token); - return this->timer_queue_->expire_single(release); -} - -int -ACE_TP_Reactor::handle_notify_events (int & /*event_count*/, - ACE_TP_Token_Guard &guard) -{ - // Get the handle on which notify calls could have occurred - ACE_HANDLE notify_handle = this->get_notify_handle (); - - int result = 0; - - // The notify was not in the list returned by - // wait_for_multiple_events (). - if (notify_handle == ACE_INVALID_HANDLE) - return result; - - // Now just do a read on the pipe.. - ACE_Notification_Buffer buffer; - - // Clear the handle of the read_mask of our - this->ready_set_.rd_mask_.clr_bit (notify_handle); - - // Keep reading notifies till we empty it or till we have a - // dispatchable buffer - while (this->notify_handler_->read_notify_pipe (notify_handle, buffer) > 0) - { - // Just figure out whether we can read any buffer that has - // dispatchable info. If not we have just been unblocked by - // another thread trying to update the reactor. If we get any - // buffer that needs dispatching we will dispatch that after - // releasing the lock - if (this->notify_handler_->is_dispatchable (buffer) > 0) - { - // Release the token before dispatching notifies... - guard.release_token (); - - // Dispatch the upcall for the notify - this->notify_handler_->dispatch_notify (buffer); - - // We had a successful dispatch. - result = 1; - - // break out of the while loop - break; - } - } - - // If we did some work, then we just return 1 which will allow us - // to get out of here. If we return 0, then we will be asked to do - // some work ie. dispacth socket events - return result; -} - -int -ACE_TP_Reactor::handle_socket_events (int &event_count, - ACE_TP_Token_Guard &guard) -{ - - // We got the lock, lets handle some I/O events. - ACE_EH_Dispatch_Info dispatch_info; - - this->get_socket_event_info (dispatch_info); - - // If there is any event handler that is ready to be dispatched, the - // dispatch information is recorded in dispatch_info. - if (!dispatch_info.dispatch ()) - { - // Check for removed handlers. - if (dispatch_info.event_handler_ == 0) - { - this->handler_rep_.unbind(dispatch_info.handle_, - dispatch_info.mask_); - } - - - return 0; - } - - // Suspend the handler so that other threads don't start dispatching - // it, if we can't suspend then return directly - // - // NOTE: This check was performed in older versions of the - // TP_Reactor. Looks like it is a waste.. - if (dispatch_info.event_handler_ != this->notify_handler_) - if (this->suspend_i (dispatch_info.handle_) == -1) - return 0; - - // Call add_reference() if needed. - if (dispatch_info.reference_counting_required_) - dispatch_info.event_handler_->add_reference (); - - // Release the lock. Others threads can start waiting. - guard.release_token (); - - int result = 0; - - // If there was an event handler ready, dispatch it. - // Decrement the event left - --event_count; - - // Dispatched an event - if (this->dispatch_socket_event (dispatch_info) == 0) - ++result; - - return result; -} - -int -ACE_TP_Reactor::get_event_for_dispatching (ACE_Time_Value *max_wait_time) -{ - // If the reactor handler state has changed, clear any remembered - // ready bits and re-scan from the master wait_set. - if (this->state_changed_) - { - this->ready_set_.rd_mask_.reset (); - this->ready_set_.wr_mask_.reset (); - this->ready_set_.ex_mask_.reset (); - - this->state_changed_ = false; - } - else - { - // This is a hack... somewhere, under certain conditions (which - // I don't understand...) the mask will have all of its bits clear, - // yet have a size_ > 0. This is an attempt to remedy the affect, - // without knowing why it happens. - - this->ready_set_.rd_mask_.sync (this->ready_set_.rd_mask_.max_set ()); - this->ready_set_.wr_mask_.sync (this->ready_set_.wr_mask_.max_set ()); - this->ready_set_.ex_mask_.sync (this->ready_set_.ex_mask_.max_set ()); - } - - return this->wait_for_multiple_events (this->ready_set_, max_wait_time); -} - -int -ACE_TP_Reactor::get_socket_event_info (ACE_EH_Dispatch_Info &event) -{ - // Check for dispatch in write, except, read. Only catch one, but if - // one is caught, be sure to clear the handle from each mask in case - // there is more than one mask set for it. This would cause problems - // if the handler is suspended for dispatching, but its set bit in - // another part of ready_set_ kept it from being dispatched. - int found_io = 0; - ACE_HANDLE handle; - - // @@todo: We can do quite a bit of code reduction here. Let me get - // it to work before I do this. - { - ACE_Handle_Set_Iterator handle_iter (this->ready_set_.wr_mask_); - - while (!found_io && (handle = handle_iter ()) != ACE_INVALID_HANDLE) - { - if (this->is_suspended_i (handle)) - continue; - - // Remember this info - event.set (handle, - this->handler_rep_.find (handle), - ACE_Event_Handler::WRITE_MASK, - &ACE_Event_Handler::handle_output); - - this->clear_handle_read_set (handle); - found_io = 1; - } - } - - if (!found_io) - { - ACE_Handle_Set_Iterator handle_iter (this->ready_set_.ex_mask_); - - while (!found_io && (handle = handle_iter ()) != ACE_INVALID_HANDLE) - { - if (this->is_suspended_i (handle)) - continue; - - // Remember this info - event.set (handle, - this->handler_rep_.find (handle), - ACE_Event_Handler::EXCEPT_MASK, - &ACE_Event_Handler::handle_exception); - - this->clear_handle_read_set (handle); - - found_io = 1; - } - } - - if (!found_io) - { - ACE_Handle_Set_Iterator handle_iter (this->ready_set_.rd_mask_); - - while (!found_io && (handle = handle_iter ()) != ACE_INVALID_HANDLE) - { - if (this->is_suspended_i (handle)) - continue; - - // Remember this info - event.set (handle, - this->handler_rep_.find (handle), - ACE_Event_Handler::READ_MASK, - &ACE_Event_Handler::handle_input); - - this->clear_handle_read_set (handle); - found_io = 1; - } - } - - return found_io; -} - -// Dispatches a single event handler -int -ACE_TP_Reactor::dispatch_socket_event (ACE_EH_Dispatch_Info &dispatch_info) -{ - ACE_TRACE ("ACE_TP_Reactor::dispatch_socket_event"); - - ACE_Event_Handler * const event_handler = dispatch_info.event_handler_; - ACE_EH_PTMF const callback = dispatch_info.callback_; - - // Check for removed handlers. - if (event_handler == 0) - return -1; - - // Upcall. If the handler returns positive value (requesting a - // reactor callback) don't set the ready-bit because it will be - // ignored if the reactor state has changed. Just call back - // as many times as the handler requests it. Other threads are off - // handling other things. - int status = 1; - while (status > 0) - status = (event_handler->*callback) (dispatch_info.handle_); - - // Post process socket event - return this->post_process_socket_event (dispatch_info, status); -} - -int -ACE_TP_Reactor::post_process_socket_event (ACE_EH_Dispatch_Info &dispatch_info, - int status) -{ - int result = 0; - - // First check if we really have to post process something, if not, then - // we don't acquire the token which saves us a lot of time. - if (status < 0 || - (dispatch_info.event_handler_ != this->notify_handler_ && - dispatch_info.resume_flag_ == - ACE_Event_Handler::ACE_REACTOR_RESUMES_HANDLER)) - { - // Get the reactor token and with this token acquired remove first the - // handler and resume it at the same time. This must be atomic, see also - // bugzilla 2395. When this is not atomic it can be that we resume the - // handle after it is reused by the OS. - ACE_TP_Token_Guard guard (this->token_); - - result = guard.acquire_token (); - - // If the guard is NOT the owner just return the retval - if (!guard.is_owner ()) - return result; - - // A different event handler may have been registered during the - // upcall if the handle was closed and then reopened, for - // example. Make sure we're removing and/or resuming the event - // handler used during the upcall. - ACE_Event_Handler const * const eh = - this->handler_rep_.find (dispatch_info.handle_); - - // Only remove or resume the event handler used during the - // upcall. - if (eh == dispatch_info.event_handler_) - { - if (status < 0) - { - result = - this->remove_handler_i (dispatch_info.handle_, - dispatch_info.mask_); - } - - // Resume handler if required. - if (dispatch_info.event_handler_ != this->notify_handler_ && - dispatch_info.resume_flag_ == - ACE_Event_Handler::ACE_REACTOR_RESUMES_HANDLER) - this->resume_i (dispatch_info.handle_); - } - } - - // Call remove_reference() if needed. - if (dispatch_info.reference_counting_required_) - dispatch_info.event_handler_->remove_reference (); - - return result; -} - -int -ACE_TP_Reactor::resumable_handler (void) -{ - return 1; -} - -int -ACE_TP_Reactor::handle_events (ACE_Time_Value &max_wait_time) -{ - return this->handle_events (&max_wait_time); -} - -void -ACE_TP_Reactor::notify_handle (ACE_HANDLE, - ACE_Reactor_Mask, - ACE_Handle_Set &, - ACE_Event_Handler *eh, - ACE_EH_PTMF) -{ - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("ACE_TP_Reactor::notify_handle: ") - ACE_TEXT ("Wrong version of notify_handle() got called\n"))); - - ACE_ASSERT (eh == 0); - ACE_UNUSED_ARG (eh); -} - -ACE_HANDLE -ACE_TP_Reactor::get_notify_handle (void) -{ - // Call the notify handler to get a handle on which we would have a - // notify waiting - ACE_HANDLE const read_handle = - this->notify_handler_->notify_handle (); - - // Check whether the rd_mask has been set on that handle. If so - // return the handle. - if (read_handle != ACE_INVALID_HANDLE && - this->ready_set_.rd_mask_.is_set (read_handle)) - { - return read_handle; - } - - // None found.. - return ACE_INVALID_HANDLE; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/TP_Reactor.h b/deps/acelite/ace/TP_Reactor.h deleted file mode 100644 index c9be2cf15..000000000 --- a/deps/acelite/ace/TP_Reactor.h +++ /dev/null @@ -1,317 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file TP_Reactor.h - * - * The ACE_TP_Reactor (aka, Thread Pool Reactor) uses the - * Leader/Followers pattern to demultiplex events among a pool of - * threads. When using a thread pool reactor, an application - * pre-spawns a fixed number of threads. When these threads - * invoke the ACE_TP_Reactor's handle_events() method, one thread - * will become the leader and wait for an event. The other - * follower threads will queue up waiting for their turn to become - * the leader. When an event occurs, the leader will pick a - * follower to become the leader and go on to handle the event. - * The consequence of using ACE_TP_Reactor is the amortization of - * the costs used to create threads. The context switching cost - * will also reduce. Moreover, the total resources used by - * threads are bounded because there are a fixed number of threads. - * - * @author Irfan Pyarali - * @author Nanbor Wang - */ -//============================================================================= - - -#ifndef ACE_TP_REACTOR_H -#define ACE_TP_REACTOR_H - -#include /**/ "ace/pre.h" - -#include "ace/Select_Reactor.h" -#include "ace/Timer_Queue.h" /* Simple forward decl won't work... */ - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_EH_Dispatch_Info - * - * @brief This structure contains information of the activated event - * handler. - */ -class ACE_EH_Dispatch_Info -{ -public: - ACE_EH_Dispatch_Info (void); - - void set (ACE_HANDLE handle, - ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask, - ACE_EH_PTMF callback); - - bool dispatch (void) const; - - ACE_HANDLE handle_; - ACE_Event_Handler *event_handler_; - ACE_Reactor_Mask mask_; - ACE_EH_PTMF callback_; - int resume_flag_; - bool reference_counting_required_; - -private: - bool dispatch_; - - // Disallow copying and assignment. - ACE_EH_Dispatch_Info (const ACE_EH_Dispatch_Info &); - ACE_EH_Dispatch_Info &operator= (const ACE_EH_Dispatch_Info &); -}; - - -/** - * @class ACE_TP_Token_Guard - * - * @brief A helper class that helps grabbing, releasing and waiting - * on tokens for a thread that tries calling handle_events (). - * - * In short, this class will be owned by one thread by creating on the - * stack. This class gives the status of the ownership of the token - * and manages the ownership - */ - -class ACE_TP_Token_Guard -{ -public: - - /// Constructor that will grab the token for us - ACE_TP_Token_Guard (ACE_Select_Reactor_Token &token); - - /// Destructor. This will release the token if it hasnt been - /// released till this point - ~ACE_TP_Token_Guard (void); - - /// Release the token .. - void release_token (void); - - /// Returns whether the thread that created this object ownes the - /// token or not. - bool is_owner (void); - - /// A helper method that grabs the token for us, after which the - /// thread that owns that can do some actual work. - int acquire_read_token (ACE_Time_Value *max_wait_time = 0); - - /** - * A helper method that grabs the token for us, after which the - * thread that owns that can do some actual work. This differs from - * acquire_read_token() as it uses acquire () to get the token instead of - * acquire_read () - */ - int acquire_token (ACE_Time_Value *max_wait_time = 0); - -private: - - // Disallow default construction. - ACE_TP_Token_Guard (void); - - // Disallow copying and assignment. - ACE_TP_Token_Guard (const ACE_TP_Token_Guard &); - ACE_TP_Token_Guard &operator= (const ACE_TP_Token_Guard &); - -private: - - /// The Select Reactor token. - ACE_Select_Reactor_Token &token_; - - /// Flag that indicate whether the thread that created this object - /// owns the token or not. A value of false indicates that this class - /// hasn't got the token (and hence the thread) and a value of true - /// vice-versa. - bool owner_; -}; - -/** - * @class ACE_TP_Reactor - * - * @brief Specialization of ACE_Select_Reactor to support thread-pool - * based event dispatching. - * - * One of the shortcomings of the ACE_Select_Reactor is that it - * does not support a thread pool-based event dispatching model, - * similar to the one in ACE_WFMO_Reactor. In ACE_Select_Reactor, only - * thread can call handle_events() at any given time. ACE_TP_Reactor - * removes this short-coming. - * - * ACE_TP_Reactor is a specialization of ACE_Select_Reactor to support - * thread pool-based event dispatching. This reactor takes advantage - * of the fact that events reported by @c select() are persistent if not - * acted upon immediately. It works by remembering the event handler - * which was just activated, suspending it for further I/O activities, - * releasing the internal lock (so that another thread can start waiting - * in the event loop) and then dispatching the event's handler outside the - * scope of the reactor lock. After the event handler has been dispatched - * the event handler is resumed for further I/O activity. - * - * This reactor implementation is best suited for situations when the - * callbacks to event handlers can take arbitrarily long and/or a number - * of threads are available to run the event loop. Note that I/O-processing - * callback code in event handlers (e.g. handle_input()) does not have to - * be modified or made thread-safe for this reactor. This is because - * before an I/O event is dispatched to an event handler, the handler is - * suspended; it is resumed by the reactor after the upcall completes. - * Therefore, multiple I/O events will not be made to one event handler - * multiple threads simultaneously. This suspend/resume protection does not - * apply to either timers scheduled with the reactor or to notifications - * requested via the reactor. When using timers and/or notifications you - * must provide proper protection for your class in the context of multiple - * threads. - */ -class ACE_Export ACE_TP_Reactor : public ACE_Select_Reactor -{ -public: - - /// Initialize ACE_TP_Reactor with the default size. - ACE_TP_Reactor (ACE_Sig_Handler * = 0, - ACE_Timer_Queue * = 0, - bool mask_signals = true, - int s_queue = ACE_Select_Reactor_Token::FIFO); - - /** - * Initialize the ACE_TP_Reactor to manage - * @a max_number_of_handles. If @a restart is non-0 then the - * ACE_Reactor's @c handle_events() method will be restarted - * automatically when @c EINTR occurs. If @a sh or - * @a tq are non-0 they are used as the signal handler and - * timer queue, respectively. - */ - ACE_TP_Reactor (size_t max_number_of_handles, - bool restart = false, - ACE_Sig_Handler *sh = 0, - ACE_Timer_Queue *tq = 0, - bool mask_signals = true, - int s_queue = ACE_Select_Reactor_Token::FIFO); - - /** - * This event loop driver that blocks for @a max_wait_time before - * returning. It will return earlier if timer events, I/O events, - * or signal events occur. Note that @a max_wait_time can be 0, in - * which case this method blocks indefinitely until events occur. - * - * @a max_wait_time is decremented to reflect how much time this call - * took. For instance, if a time value of 3 seconds is passed to - * handle_events and an event occurs after 2 seconds, - * @a max_wait_time will equal 1 second. This can be used if an - * application wishes to handle events for some fixed amount of - * time. - * - * @return The total number of events that were dispatched; 0 if the - * @a max_wait_time elapsed without dispatching any handlers, or -1 - * if an error occurs (check @c errno for more information). - */ - virtual int handle_events (ACE_Time_Value *max_wait_time = 0); - - virtual int handle_events (ACE_Time_Value &max_wait_time); - - /// Does the reactor allow the application to resume the handle on - /// its own ie. can it pass on the control of handle resumption to - /// the application. The TP reactor has can allow applications to - /// resume handles. So return a positive value. - virtual int resumable_handler (void); - - /// Called from handle events - static void no_op_sleep_hook (void *); - - /// The ACE_TP_Reactor implementation does not have a single owner thread. - /// Attempts to set the owner explicitly are ignored. The reported owner - /// thread is the current Leader in the pattern. - virtual int owner (ACE_thread_t n_id, ACE_thread_t *o_id = 0); - - /// Return the thread ID of the current Leader. - virtual int owner (ACE_thread_t *t_id); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - // = Internal methods that do the actual work. - - /// Template method from the base class. - virtual void clear_dispatch_mask (ACE_HANDLE handle, - ACE_Reactor_Mask mask); - - /// Dispatch just 1 signal, timer, notification handlers - int dispatch_i (ACE_Time_Value *max_wait_time, - ACE_TP_Token_Guard &guard); - - /// Get the event that needs dispatching. It could be either a - /// signal, timer, notification handlers or return possibly 1 I/O - /// handler for dispatching. In the most common use case, this would - /// return 1 I/O handler for dispatching - int get_event_for_dispatching (ACE_Time_Value *max_wait_time); - -#if 0 - // @Ciju - // signal handling isn't in a production state yet. - // Commenting it out for now. - - /// Method to handle signals - /// @note It is just busted at this point in time. - int handle_signals (int &event_count, - ACE_TP_Token_Guard &g); -#endif // #if 0 - - /// Handle timer events - int handle_timer_events (int &event_count, - ACE_TP_Token_Guard &g); - - /// Handle notify events - int handle_notify_events (int &event_count, - ACE_TP_Token_Guard &g); - - /// handle socket events - int handle_socket_events (int &event_count, - ACE_TP_Token_Guard &g); - - /// This method shouldn't get called. - virtual void notify_handle (ACE_HANDLE handle, - ACE_Reactor_Mask mask, - ACE_Handle_Set &, - ACE_Event_Handler *eh, - ACE_EH_PTMF callback); -private: - - /// Get the handle of the notify pipe from the ready set if there is - /// an event in the notify pipe. - ACE_HANDLE get_notify_handle (void); - - /// Get socket event dispatch information. - int get_socket_event_info (ACE_EH_Dispatch_Info &info); - - /// Notify the appropriate in the context of the - /// associated with that a particular event has occurred. - int dispatch_socket_event (ACE_EH_Dispatch_Info &dispatch_info); - - /// Clear the @a handle from the read_set - void clear_handle_read_set (ACE_HANDLE handle); - - int post_process_socket_event (ACE_EH_Dispatch_Info &dispatch_info,int status); - -private: - /// Deny access since member-wise won't work... - ACE_TP_Reactor (const ACE_TP_Reactor &); - ACE_TP_Reactor &operator = (const ACE_TP_Reactor &); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/TP_Reactor.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* ACE_TP_REACTOR_H */ diff --git a/deps/acelite/ace/TP_Reactor.inl b/deps/acelite/ace/TP_Reactor.inl deleted file mode 100644 index f793fd23c..000000000 --- a/deps/acelite/ace/TP_Reactor.inl +++ /dev/null @@ -1,116 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/************************************************************************/ -// Methods for ACE_EH_Dispatch_Info -/************************************************************************/ - -ACE_INLINE -ACE_EH_Dispatch_Info::ACE_EH_Dispatch_Info (void) : - handle_ (ACE_INVALID_HANDLE), - event_handler_ (0), - mask_ (ACE_Event_Handler::NULL_MASK), - callback_ (0), - resume_flag_ (ACE_Event_Handler::ACE_REACTOR_RESUMES_HANDLER), - reference_counting_required_ (false), - dispatch_ (false) -{ -} - -ACE_INLINE void -ACE_EH_Dispatch_Info::set (ACE_HANDLE handle, - ACE_Event_Handler *event_handler, - ACE_Reactor_Mask mask, - ACE_EH_PTMF callback) -{ - this->dispatch_ = true; - - this->handle_ = handle; - this->event_handler_ = event_handler; - this->mask_ = mask; - this->callback_ = callback; - if (event_handler_) - { - this->resume_flag_ = event_handler->resume_handler (); - this->reference_counting_required_ = - (event_handler_->reference_counting_policy ().value () == - ACE_Event_Handler::Reference_Counting_Policy::ENABLED); - } - else - this->dispatch_ = false; -} - -ACE_INLINE bool -ACE_EH_Dispatch_Info::dispatch (void) const -{ - return this->dispatch_; -} - -/************************************************************************/ -// Methods for ACE_TP_Token_Guard -/************************************************************************/ - -ACE_INLINE -ACE_TP_Token_Guard::ACE_TP_Token_Guard (ACE_Select_Reactor_Token &token) - - : token_ (token), - owner_ (false) -{ -} - -ACE_INLINE -ACE_TP_Token_Guard::~ACE_TP_Token_Guard (void) -{ - if (this->owner_) - { - ACE_MT (this->token_.release ()); - this->owner_ = false; - } -} - -ACE_INLINE void -ACE_TP_Token_Guard::release_token (void) -{ - if (this->owner_) - { - ACE_MT (this->token_.release ()); - - // We are not the owner anymore.. - this->owner_ = false; - } -} - -ACE_INLINE bool -ACE_TP_Token_Guard::is_owner (void) -{ - return this->owner_; -} - - -/************************************************************************/ -// Methods for ACE_TP_Reactor -/************************************************************************/ - -ACE_INLINE void -ACE_TP_Reactor::no_op_sleep_hook (void *) -{ -} - -ACE_INLINE void -ACE_TP_Reactor::clear_handle_read_set (ACE_HANDLE handle) -{ - this->ready_set_.wr_mask_.clr_bit (handle); - this->ready_set_.ex_mask_.clr_bit (handle); - this->ready_set_.rd_mask_.clr_bit (handle); -} - -ACE_INLINE void -ACE_TP_Reactor::clear_dispatch_mask (ACE_HANDLE , - ACE_Reactor_Mask ) -{ - this->ready_set_.rd_mask_.reset (); - this->ready_set_.wr_mask_.reset (); - this->ready_set_.ex_mask_.reset (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/TSS_Adapter.cpp b/deps/acelite/ace/TSS_Adapter.cpp deleted file mode 100644 index ee1f55fdc..000000000 --- a/deps/acelite/ace/TSS_Adapter.cpp +++ /dev/null @@ -1,44 +0,0 @@ -/** - * @file TSS_Adapter.cpp - * - * Originally in Synch.cpp - * - * @author Douglas C. Schmidt - */ - -#include "ace/TSS_Adapter.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_TSS_Adapter::ACE_TSS_Adapter (void *object, ACE_THR_DEST f) - : ts_obj_ (object), - func_ (f) -{ -} - -ACE_ALLOC_HOOK_DEFINE(ACE_TSS_Adapter); - -void -ACE_TSS_Adapter::cleanup (void) -{ - (*this->func_)(this->ts_obj_); // call cleanup routine for ts_obj_ -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -extern "C" ACE_Export void -ACE_TSS_C_cleanup (void *object) -{ - if (object != 0) - { - ACE_TSS_Adapter * const tss_adapter = (ACE_TSS_Adapter *) object; - // Perform cleanup on the real TS object. - tss_adapter->cleanup (); - // Delete the adapter object. - delete tss_adapter; - } -} diff --git a/deps/acelite/ace/TSS_Adapter.h b/deps/acelite/ace/TSS_Adapter.h deleted file mode 100644 index 376f51792..000000000 --- a/deps/acelite/ace/TSS_Adapter.h +++ /dev/null @@ -1,60 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file TSS_Adapter.h - * - * Originally in Synch.h - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_TSS_ADAPTER_H -#define ACE_TSS_ADAPTER_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_TSS_Adapter - * - * @brief This class encapsulates a TSS object and its associated - * C++ destructor function. It is used by the ACE_TSS... - * methods (in Synch_T.cpp) in order to allow an extern - * "C" cleanup routine to be used. - * - * Objects of this class are stored in thread specific - * storage. ts_obj_ points to the "real" object and - * func_ is a pointer to the C++ cleanup function for ts_obj_. - */ -class ACE_Export ACE_TSS_Adapter -{ -public: - /// Initialize the adapter. - ACE_TSS_Adapter (void *object, ACE_THR_DEST f); - - /// Perform the cleanup operation. - void cleanup (void); - - ACE_ALLOC_HOOK_DECLARE; - -//private: - - /// The real TS object. - void * const ts_obj_; - - /// The real cleanup routine for ts_obj; - ACE_THR_DEST func_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" -#endif /* ACE_TSS_ADAPTER_H */ diff --git a/deps/acelite/ace/TSS_T.cpp b/deps/acelite/ace/TSS_T.cpp deleted file mode 100644 index bee8257b0..000000000 --- a/deps/acelite/ace/TSS_T.cpp +++ /dev/null @@ -1,669 +0,0 @@ -#ifndef ACE_TSS_T_CPP -#define ACE_TSS_T_CPP - -#include "ace/TSS_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (__ACE_INLINE__) -#include "ace/TSS_T.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Thread.h" -#include "ace/Log_Category.h" -#include "ace/Guard_T.h" -#include "ace/OS_NS_stdio.h" -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if defined (ACE_HAS_THR_C_DEST) -# include "ace/TSS_Adapter.h" -#endif /* ACE_HAS_THR_C_DEST */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_TSS) - -#if defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) -# if defined (ACE_HAS_THR_C_DEST) -extern "C" ACE_Export void ACE_TSS_C_cleanup (void *); -# endif /* ACE_HAS_THR_C_DEST */ -#endif /* defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) */ - -template -ACE_TSS::~ACE_TSS (void) -{ -#if defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) - if (this->once_) - { -# if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = this->ts_value (); - this->ts_value (0); - ACE_TSS_C_cleanup (tss_adapter); -# else - TYPE *ts_obj = this->ts_value (); - this->ts_value (0); -# if !defined ACE_HAS_LYNXOS_178 || defined ACE_HAS_TSS_EMULATION - // A bug in LynxOS-178 causes pthread_setspecific (called from ts_value(0) - // above) to call the cleanup function, so we need to avoid calling it here. - ACE_TSS::cleanup (ts_obj); -# else - ACE_UNUSED_ARG (ts_obj); -# endif -# endif /* ACE_HAS_THR_C_DEST */ - - ACE_OS::thr_key_detach (this->key_); - ACE_OS::thr_keyfree (this->key_); - } -#else // defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) - // We own it, we need to delete it. - delete type_; -#endif // defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) -} - -template TYPE * -ACE_TSS::operator-> () const -{ - return this->ts_get (); -} - -template -ACE_TSS::operator TYPE *(void) const -{ - return this->ts_get (); -} - -template TYPE * -ACE_TSS::make_TSS_TYPE (void) const -{ - TYPE *temp = 0; - ACE_NEW_RETURN (temp, - TYPE, - 0); - return temp; -} - -template void -ACE_TSS::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -#if defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - this->keylock_.dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("key_ = %d\n"), this->key_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nonce_ = %d\n"), this->once_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) */ -#endif /* ACE_HAS_DUMP */ -} - -#if defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) - -template void -ACE_TSS::cleanup (void *ptr) -{ - // Cast this to the concrete TYPE * so the destructor gets called. - delete (TYPE *) ptr; -} - -template int -ACE_TSS::ts_init (void) -{ - // Ensure that we are serialized! - ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->keylock_, 0); - - // Use the Double-Check pattern to make sure we only create the key - // once! - if (!this->once_) - { - if (ACE_Thread::keycreate (&this->key_, -#if defined (ACE_HAS_THR_C_DEST) - &ACE_TSS_C_cleanup -#else - &ACE_TSS::cleanup -#endif /* ACE_HAS_THR_C_DEST */ - ) != 0) - return -1; // Major problems, this should *never* happen! - else - { - // This *must* come last to avoid race conditions! - this->once_ = true; - return 0; - } - } - - return 0; -} - -template -ACE_TSS::ACE_TSS (TYPE *ts_obj) - : once_ (false), - key_ (ACE_OS::NULL_key) -{ - // If caller has passed us a non-NULL TYPE *, then we'll just use - // this to initialize the thread-specific value. Thus, subsequent - // calls to operator->() will return this value. This is useful - // since it enables us to assign objects to thread-specific data - // that have arbitrarily complex constructors! - - if (ts_obj != 0) - { - if (this->ts_init () == -1) - { - // Save/restore errno. - ACE_Errno_Guard error (errno); - // What should we do if this call fails?! -#if defined (ACE_HAS_WINCE) - ::MessageBox (0, - ACE_TEXT ("ACE_Thread::keycreate() failed!"), - ACE_TEXT ("ACE_TSS::ACE_TSS"), - MB_OK); -#elif !defined (ACE_LACKS_VA_FUNCTIONS) - ACE_OS::fprintf (stderr, - "ACE_Thread::keycreate() failed!"); -#endif /* ACE_HAS_WINCE */ - return; - } - -#if defined (ACE_HAS_THR_C_DEST) - // Encapsulate a ts_obj and it's destructor in an - // ACE_TSS_Adapter. - ACE_TSS_Adapter *tss_adapter = 0; - ACE_NEW (tss_adapter, - ACE_TSS_Adapter ((void *) ts_obj, - ACE_TSS::cleanup)); - - // Put the adapter in thread specific storage - if (this->ts_value (tss_adapter) == -1) - { - delete tss_adapter; - } -#else - this->ts_value (ts_obj); -#endif /* ACE_HAS_THR_C_DEST */ - } -} - -template TYPE * -ACE_TSS::ts_get (void) const -{ - if (!this->once_) - { - // Create and initialize thread-specific ts_obj. - if (const_cast< ACE_TSS < TYPE > * >(this)->ts_init () == -1) - // Seriously wrong.. - return 0; - } - - TYPE *ts_obj = 0; - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = this->ts_value (); - ACE_TSS_Adapter *fake_tss_adapter = 0; - - // If tss_adapter is not 0 but its ts_obj_ is 0 then we still need to create - // a proper ts_obj. That's the intent of this member function. - if (tss_adapter != 0 && tss_adapter->ts_obj_ == 0) - { - fake_tss_adapter = tss_adapter; - tss_adapter = 0; - } - - // Check to see if this is the first time in for this thread. - if (tss_adapter == 0) -#else - ts_obj = this->ts_value (); - - // Check to see if this is the first time in for this thread. - if (ts_obj == 0) -#endif /* ACE_HAS_THR_C_DEST */ - { - // Allocate memory off the heap and store it in a pointer in - // thread-specific storage (on the stack...). - - ts_obj = this->make_TSS_TYPE (); - - if (ts_obj == 0) - return 0; - -#if defined (ACE_HAS_THR_C_DEST) - // Encapsulate a ts_obj and it's destructor in an - // ACE_TSS_Adapter. - ACE_NEW_RETURN (tss_adapter, - ACE_TSS_Adapter (ts_obj, - ACE_TSS::cleanup), 0); - - // Put the adapter in thread specific storage - if (this->ts_value (tss_adapter) == -1) - { - delete tss_adapter; - delete ts_obj; - return 0; // Major problems, this should *never* happen! - } -#else - // Store the dynamically allocated pointer in thread-specific - // storage. - if (this->ts_value (ts_obj) == -1) - { - delete ts_obj; - return 0; // Major problems, this should *never* happen! - } -#endif /* ACE_HAS_THR_C_DEST */ - } - -#if defined (ACE_HAS_THR_C_DEST) - // Delete the adapter that didn't actually have a real ts_obj. - delete fake_tss_adapter; - // Return the underlying ts object. - return static_cast (tss_adapter->ts_obj_); -#else - return ts_obj; -#endif /* ACE_HAS_THR_C_DEST */ -} - -// Get the thread-specific object for the key associated with this -// object. Returns 0 if the ts_obj has never been initialized, -// otherwise returns a pointer to the ts_obj. - -template TYPE * -ACE_TSS::ts_object (void) const -{ - if (!this->once_) // Return 0 if we've never been initialized. - return 0; - - TYPE *ts_obj = 0; - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = this->ts_value (); - - if (tss_adapter != 0) - { - // Extract the real TS object. - ts_obj = static_cast (tss_adapter->ts_obj_); - } -#else - ts_obj = this->ts_value (); -#endif /* ACE_HAS_THR_C_DEST */ - - return ts_obj; -} - -template TYPE * -ACE_TSS::ts_object (TYPE *new_ts_obj) -{ - // Note, we shouldn't hold the keylock at this point because - // does it for us and we'll end up with deadlock - // otherwise... - if (!this->once_) - { - // Create and initialize thread-specific ts_obj. - if (this->ts_init () == -1) - return 0; - } - - TYPE *ts_obj = 0; - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = this->ts_value (); - - if (tss_adapter != 0) - { - ts_obj = static_cast (tss_adapter->ts_obj_); - // Don't delete tss_adapter yet. It can be double-deleted - // in case setspecific below fails. - } - - ACE_TSS_Adapter *new_tss_adapter = 0; - ACE_NEW_RETURN (new_tss_adapter, - ACE_TSS_Adapter ((void *) new_ts_obj, - ACE_TSS::cleanup), - 0); - - if (this->ts_value (new_tss_adapter) == -1) - { - delete new_tss_adapter; - } - else - { - // Now it's fine to delete the old tss_adapter. - delete tss_adapter; - } -#else - ts_obj = this->ts_value (); - this->ts_value (new_ts_obj); -#endif /* ACE_HAS_THR_C_DEST */ - - return ts_obj; -} - -ACE_ALLOC_HOOK_DEFINE_Tc(ACE_TSS_Guard) - -template void -ACE_TSS_Guard::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("key_ = %d\n"), this->key_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -template void -ACE_TSS_Guard::init_key (void) -{ - this->key_ = ACE_OS::NULL_key; - ACE_Thread::keycreate (&this->key_, -#if defined (ACE_HAS_THR_C_DEST) - &ACE_TSS_C_cleanup -#else - &ACE_TSS_Guard::cleanup -#endif /* ACE_HAS_THR_C_DEST */ - ); -} - -template -ACE_TSS_Guard::ACE_TSS_Guard (void) -{ - this->init_key (); -} - -template int -ACE_TSS_Guard::release (void) -{ - Guard_Type *guard = 0; - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = 0; - void *temp = tss_adapter; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - tss_adapter = static_cast (temp); - guard = static_cast (tss_adapter->ts_obj_); -#else - void *temp = guard; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - guard = static_cast (temp); -#endif /* ACE_HAS_THR_C_DEST */ - - return guard->release (); -} - -template int -ACE_TSS_Guard::remove (void) -{ - Guard_Type *guard = 0; - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = 0; - void *temp = tss_adapter; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - tss_adapter = static_cast (temp); - guard = static_cast (tss_adapter->ts_obj_); -#else - void *temp = guard; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - guard = static_cast (temp); -#endif /* ACE_HAS_THR_C_DEST */ - - return guard->remove (); -} - -template -ACE_TSS_Guard::~ACE_TSS_Guard (void) -{ - Guard_Type *guard = 0; - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = 0; - void *temp = tss_adapter; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - tss_adapter = static_cast (temp); - guard = static_cast (tss_adapter->ts_obj_); -#else - void *temp = guard; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - guard = static_cast (temp); -#endif /* ACE_HAS_THR_C_DEST */ - - // Make sure that this pointer is NULL when we shut down... - ACE_Thread::setspecific (this->key_, 0); - ACE_Thread::keyfree (this->key_); - // Destructor releases lock. - delete guard; -} - -template void -ACE_TSS_Guard::cleanup (void *ptr) -{ - // Destructor releases lock. - delete (Guard_Type *) ptr; -} - -template -ACE_TSS_Guard::ACE_TSS_Guard (ACE_LOCK &lock, bool block) -{ - this->init_key (); - Guard_Type *guard = 0; - ACE_NEW (guard, - Guard_Type (lock, block)); - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = 0; - ACE_NEW (tss_adapter, - ACE_TSS_Adapter ((void *) guard, - ACE_TSS_Guard::cleanup)); - ACE_Thread::setspecific (this->key_, - (void *) tss_adapter); -#else - ACE_Thread::setspecific (this->key_, - (void *) guard); -#endif /* ACE_HAS_THR_C_DEST */ -} - -template int -ACE_TSS_Guard::acquire (void) -{ - Guard_Type *guard = 0; - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = 0; - void *temp = tss_adapter; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - tss_adapter = static_cast (temp); - guard = static_cast (tss_adapter->ts_obj_); -#else - void *temp = guard; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - guard = static_cast (temp); -#endif /* ACE_HAS_THR_C_DEST */ - - return guard->acquire (); -} - -template int -ACE_TSS_Guard::tryacquire (void) -{ - Guard_Type *guard = 0; - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = 0; - void *temp = tss_adapter; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - tss_adapter = static_cast (temp); - guard = static_cast (tss_adapter->ts_obj_); -#else - void *temp = guard; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - guard = static_cast (temp); -#endif /* ACE_HAS_THR_C_DEST */ - - return guard->tryacquire (); -} - -template -ACE_TSS_Write_Guard::ACE_TSS_Write_Guard (ACE_LOCK &lock, - bool block) -{ - this->init_key (); - Guard_Type *guard = 0; - ACE_NEW (guard, - Write_Guard_Type (lock, block)); - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = 0; - ACE_NEW (tss_adapter, - ACE_TSS_Adapter ((void *) guard, - ACE_TSS_Guard::cleanup)); - ACE_Thread::setspecific (this->key_, (void *) tss_adapter); -#else - ACE_Thread::setspecific (this->key_, (void *) guard); -#endif /* ACE_HAS_THR_C_DEST */ -} - -template int -ACE_TSS_Write_Guard::acquire (void) -{ - Write_Guard_Type *guard = 0; - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = 0; - void *temp = tss_adapter; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - tss_adapter = static_cast (temp); - guard = static_cast (tss_adapter->ts_obj_); -#else - void *temp = guard; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - guard = static_cast (temp); -#endif /* ACE_HAS_THR_C_DEST */ - - return guard->acquire_write (); -} - -template int -ACE_TSS_Write_Guard::tryacquire (void) -{ - Write_Guard_Type *guard = 0; - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = 0; - void *temp = tss_adapter; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - tss_adapter = static_cast (temp); - guard = static_cast (tss_adapter->ts_obj_); -#else - void *temp = guard; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - guard = static_cast (temp); -#endif /* ACE_HAS_THR_C_DEST */ - - return guard->tryacquire_write (); -} - -template int -ACE_TSS_Write_Guard::acquire_write (void) -{ - return this->acquire (); -} - -template int -ACE_TSS_Write_Guard::tryacquire_write (void) -{ - return this->tryacquire (); -} - -template void -ACE_TSS_Write_Guard::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TSS_Guard::dump (); -#endif /* ACE_HAS_DUMP */ -} - -template -ACE_TSS_Read_Guard::ACE_TSS_Read_Guard (ACE_LOCK &lock, bool block) -{ - this->init_key (); - Guard_Type *guard = 0; - ACE_NEW (guard, - Read_Guard_Type (lock, block)); -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter; - ACE_NEW (tss_adapter, - ACE_TSS_Adapter ((void *)guard, - ACE_TSS_Guard::cleanup)); - ACE_Thread::setspecific (this->key_, - (void *) tss_adapter); -#else - ACE_Thread::setspecific (this->key_, - (void *) guard); -#endif /* ACE_HAS_THR_C_DEST */ -} - -template int -ACE_TSS_Read_Guard::acquire (void) -{ - Read_Guard_Type *guard = 0; - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = 0; - void *temp = tss_adapter; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - tss_adapter = static_cast (temp); - guard = static_cast (tss_adapter->ts_obj_); -#else - void *temp = guard; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - guard = static_cast (temp); -#endif /* ACE_HAS_THR_C_DEST */ - - return guard->acquire_read (); -} - -template int -ACE_TSS_Read_Guard::tryacquire (void) -{ - Read_Guard_Type *guard = 0; - -#if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *tss_adapter = 0; - void *temp = tss_adapter; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - tss_adapter = static_cast (temp); - guard = static_cast (tss_adapter->ts_obj_); -#else - void *temp = guard; // Need this temp to keep G++ from complaining. - ACE_Thread::getspecific (this->key_, &temp); - guard = static_cast (temp); -#endif /* ACE_HAS_THR_C_DEST */ - - return guard->tryacquire_read (); -} - -template int -ACE_TSS_Read_Guard::acquire_read (void) -{ - return this->acquire (); -} - -template int -ACE_TSS_Read_Guard::tryacquire_read (void) -{ - return this->tryacquire (); -} - -template void -ACE_TSS_Read_Guard::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TSS_Guard::dump (); -#endif /* ACE_HAS_DUMP */ -} - -#endif /* defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) */ - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_TSS_T_CPP */ diff --git a/deps/acelite/ace/TSS_T.h b/deps/acelite/ace/TSS_T.h deleted file mode 100644 index d3097d544..000000000 --- a/deps/acelite/ace/TSS_T.h +++ /dev/null @@ -1,266 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file TSS_T.h - * - * Moved from Synch.h. - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_TSS_T_H -#define ACE_TSS_T_H -#include /**/ "ace/pre.h" - -#include "ace/Lock.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -// This should probably go somewhere else, but it's only used here and -// in Thread_Manager. -// Note there is no ACE_TSS_SET because one would typically do -// 'ACE_TSS_GET()->xyz_ = value', so the macro would have been too -// complicated. -# if defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) -# define ACE_TSS_TYPE(T) ACE_TSS< T > -# define ACE_TSS_GET(I, T) ((I)->operator T * ()) -# else -# define ACE_TSS_TYPE(T) T -# define ACE_TSS_GET(I, T) (I) -# endif /* ACE_HAS_THREADS && (ACE_HAS_THREAD_SPECIFIC_STORAGE || ACE_HAS_TSS_EMULATION) */ - -#include "ace/Thread_Mutex.h" -#include "ace/Copy_Disabled.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_HAS_THR_C_DEST) -class ACE_TSS_Adapter; -#endif - -/** - * @class ACE_TSS - * - * @brief Allows objects that are "physically" in thread specific - * storage (i.e., private to a thread) to be accessed as though - * they were "logically" global to a program. - * - * This class helps to maintain a separate copy of an object for each thread - * that needs access to it. All threads access a single instance of ACE_TSS - * to obtain a pointer to a thread-specific copy of a TYPE object. Using - * a pointer to TYPE in TSS instead of TYPE itself is useful because, - * in addition to avoiding copies on what may be a complex class, it allows - * assignment of objects to thread-specific data that have arbitrarily - * complex constructors. - * - * When the ACE_TSS object is destroyed, all threads's instances of the - * data are deleted. - * - * Modern compilers have no problem using a built-in type for @c TYPE. - * However, if you must use an older compiler that won't work with a built-in - * type, the ACE_TSS_Type_Adapter class template, below, can be used for - * adapting built-in types to work with ACE_TSS. - * - * @note Beware when creating static instances of this type - * (as with any other, btw). The unpredictable order of initialization - * across different platforms may cause a situation where one uses - * the instance before it is fully initialized. That's why typically - * instances of this type are dynamicaly allocated. On the stack it is - * typically allocated inside the ACE_Thread::svc() method which - * limits its lifetime appropriately. - */ -template -class ACE_TSS : private ACE_Copy_Disabled -{ -public: - /** - * Default constructor. Can also initialize this ACE_TSS instance, - * readying it for use by the calling thread as well as all other - * threads in the process. If the constructor does not initialize this - * object, the first access to it will perform the initialization, which - * could possibly (under odd error conditions) fail. - * - * @param ts_obj If non-zero, this object is initialized for use by - * all threads and @a ts_obj is used to set the - * thread-specific value for the calling thread. Other - * threads use the ts_object (TYPE *) method to set - * a specific value. - */ - ACE_TSS (TYPE *ts_obj = 0); - - /// Deregister this object from thread-specific storage administration. - /// Will cause all threads' copies of TYPE to be destroyed. - virtual ~ACE_TSS (void); - - /** - * Set the thread-specific object for the calling thread. - * If this object has not been initialized yet, this method performs the - * initialization. - * - * @param new_ts_obj The new value for the calling thread's copy of - * this object. - * - * @return The previous value of the calling thread's copy of this - * object; 0 if there was no previous value. This method also - * returns 0 on errors. To tell the difference between an error - * and a returned 0 pointer, it's recommended that one set errno - * to 0 prior to calling ts_object() and check for a new errno - * value if ts_object() returns 0. - */ - TYPE *ts_object (TYPE *new_ts_obj); - - /** @name Accessors - * - * All accessors return a pointer to the calling thread's copy of the - * TYPE data. The pointer may be 0 on error conditions or if the calling - * thread's copy of the data has not yet been set. See specific method - * descriptions for complete details. - */ - //@{ - /** - * Get the thread-specific object for this object. - * - * @return 0 if the object has never been initialized, otherwise returns - * the calling thread's copy of the data. The returned pointer - * may be 0 under odd error conditions; check errno for further - * information. - */ - TYPE *ts_object (void) const; - - /** - * Use a "smart pointer" to get the thread-specific data associated - * with this object. - * If this ACE_TSS object hasn't been initialized, this method - * will initialize it as a side-affect. If the calling thread has not - * set a value, a default-constructed instance of TYPE is allocated and it - * becomes the thread's instance. - * - * @return The calling thread's copy of the data. The returned pointer - * may be 0 under odd error conditions; check errno for further - * information. - */ - TYPE *operator-> () const; - - /** - * Obtain a pointer to the calling thread's TYPE object. - * If this ACE_TSS object hasn't been initialized, this method - * will initialize it as a side-affect. If the calling thread has not - * set a value, a default-constructed instance of TYPE is allocated and it - * becomes the thread's instance. - * - * @return The calling thread's copy of the data. The returned pointer - * may be 0 under odd error conditions; check errno for further - * information. - */ - operator TYPE *(void) const; - - //@} - - /// Hook for construction parameters. - virtual TYPE *make_TSS_TYPE (void) const; - - // = Utility methods. - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Actually implements the code that retrieves the object from - /// thread-specific storage. - TYPE *ts_get (void) const; - - /// Factors out common code for initializing TSS. This must NOT be - /// called with the lock held... - int ts_init (void); - -#if !(defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))) - /// This implementation only works for non-threading systems... - TYPE *type_; -#else - /// Avoid race conditions during initialization. - ACE_Thread_Mutex keylock_; - - /// "First time in" flag. - volatile bool once_; - - /// Key for the thread-specific error data. - ACE_thread_key_t key_; - - /// "Destructor" that deletes internal TYPE * when thread exits. - static void cleanup (void *ptr); - - /// Obtains a plain value stored in the thread-specific storage. -# if defined (ACE_HAS_THR_C_DEST) - ACE_TSS_Adapter *ts_value (void) const; -# else - TYPE *ts_value (void) const; -# endif /* ACE_HAS_THR_C_DEST */ - - /// Stores a new plain value in the thread-specific storage. -# if defined (ACE_HAS_THR_C_DEST) - int ts_value (ACE_TSS_Adapter *new_tss_adapter) const; -# else - int ts_value (TYPE *new_ts_obj) const; -# endif /* ACE_HAS_THR_C_DEST */ -#endif /* defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) */ -}; - -/** - * @class ACE_TSS_Type_Adapter - * - * @brief Adapter that allows built-in types to be used with ACE_TSS. - * - * Wraps a value of a built-in type, providing conversions to - * and from the type. Example use with ACE_TSS: - * ACE_TSS > i; - * *i = 37; - * ACE_OS::fprintf (stderr, "%d\n", *i); - * Unfortunately, though, some compilers have trouble with the - * implicit type conversions. This seems to work better: - * ACE_TSS > i; - * i->operator int & () = 37; - * ACE_OS::fprintf (stderr, "%d\n", i->operator int ()); - */ -template -class ACE_TSS_Type_Adapter -{ -public: - /// Constructor. Inlined here so that it should _always_ be inlined. - ACE_TSS_Type_Adapter (const TYPE value = 0): value_ (value) {} - - /// TYPE conversion. Inlined here so that it should _always_ be - /// inlined. - operator TYPE () const { return value_; }; - - /// TYPE & conversion. Inlined here so that it should _always_ be - /// inlined. - operator TYPE &() { return value_; }; - -private: - /// The wrapped value. - TYPE value_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/TSS_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/TSS_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("TSS_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_TSS_T_H */ diff --git a/deps/acelite/ace/TSS_T.inl b/deps/acelite/ace/TSS_T.inl deleted file mode 100644 index 7e68976c8..000000000 --- a/deps/acelite/ace/TSS_T.inl +++ /dev/null @@ -1,100 +0,0 @@ -// -*- C++ -*- -#include "ace/Thread.h" -#include "ace/Log_Category.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -#if !(defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))) - -template ACE_INLINE -ACE_TSS::ACE_TSS (TYPE *type) - : type_ (type) -{ -} - -template ACE_INLINE int -ACE_TSS::ts_init (void) -{ - return 0; -} - -template ACE_INLINE TYPE * -ACE_TSS::ts_object (void) const -{ - return this->type_; -} - -template ACE_INLINE TYPE * -ACE_TSS::ts_object (TYPE *type) -{ - this->type_ = type; - return this->type_; -} - -template ACE_INLINE TYPE * -ACE_TSS::ts_get (void) const -{ - return this->type_; -} - -#else - -# if defined (ACE_HAS_THR_C_DEST) -template ACE_INLINE ACE_TSS_Adapter * -ACE_TSS::ts_value (void) const -{ - // Get the tss adapter from thread-specific storage - void *temp = 0; - if (ACE_Thread::getspecific (this->key_, &temp) == -1) - { - return 0; // This should not happen! - } - return static_cast (temp); -} -# else -template ACE_INLINE TYPE * -ACE_TSS::ts_value (void) const -{ - void *temp = 0; - if (ACE_Thread::getspecific (this->key_, &temp) == -1) - { - return 0; // This should not happen! - } - return static_cast (temp); -} -# endif /* ACE_HAS_THR_C_DEST */ - -# if defined (ACE_HAS_THR_C_DEST) -template ACE_INLINE int -ACE_TSS::ts_value (ACE_TSS_Adapter *new_tss_adapter) const -{ - if (ACE_Thread::setspecific (this->key_, - (void *) new_tss_adapter) != 0) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("Error: ACE_Thread::setspecific() failed!"))); - return -1; - } - - return 0; -} -# else -template ACE_INLINE int -ACE_TSS::ts_value (TYPE *new_ts_obj) const -{ - if (ACE_Thread::setspecific (this->key_, (void *) new_ts_obj) != 0) - { - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("Error: ACE_Thread::setspecific() failed!"))); - return -1; - } - - return 0; -} -# endif /* ACE_HAS_THR_C_DEST */ - -#endif /* ! (defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))) */ - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/TTY_IO.cpp b/deps/acelite/ace/TTY_IO.cpp deleted file mode 100644 index 53c56badd..000000000 --- a/deps/acelite/ace/TTY_IO.cpp +++ /dev/null @@ -1,710 +0,0 @@ -#include "ace/TTY_IO.h" -#include "ace/OS_NS_errno.h" -#include "ace/OS_NS_string.h" -#include "ace/OS_NS_strings.h" - -#if defined (ACE_HAS_TERMIOS) -# include "ace/os_include/os_termios.h" -#elif defined (ACE_HAS_TERMIO) -# include -#endif - -namespace -{ - const char ACE_TTY_IO_NONE[] = "none"; -#if defined (ACE_HAS_TERMIOS) || defined (ACE_HAS_TERMIO) || defined (ACE_WIN32) - const char ACE_TTY_IO_ODD[] = "odd"; - const char ACE_TTY_IO_EVEN[] = "even"; -#endif -#if defined (ACE_WIN32) - const char ACE_TTY_IO_MARK[] = "mark"; - const char ACE_TTY_IO_SPACE[] = "space"; -#endif /* ACE_WIN32 */ -} - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_TTY_IO::ACE_TTY_IO (void) -{ -} - -ACE_TTY_IO::Serial_Params::Serial_Params (void) -{ - baudrate = 9600; - xonlim = 0; - xofflim = 0; - readmincharacters = 0; - readtimeoutmsec = 10000; - paritymode = ACE_TTY_IO_NONE; - ctsenb = false; - rtsenb = 0; - xinenb = false; - xoutenb = false; - modem = false; - rcvenb = true; - dsrenb = false; - dtrdisable = false; - databits = 8; - stopbits = 1; -} - -// Interface for reading/writing serial device parameters - -int ACE_TTY_IO::control (Control_Mode cmd, Serial_Params *arg) const -{ -#if defined (ACE_HAS_TERMIOS) || defined (ACE_HAS_TERMIO) - -#if defined (ACE_HAS_TERMIOS) - struct termios devpar; - speed_t newbaudrate = 0; - if (tcgetattr (get_handle () , &devpar) == -1) -#elif defined (TCGETS) - struct termios devpar; - unsigned int newbaudrate = 0; - if (this->ACE_IO_SAP::control (TCGETS, static_cast(&devpar)) == -1) -#elif defined (TCGETA) - struct termio devpar; - unsigned int newbaudrate = 0; - if (this->ACE_IO_SAP::control (TCGETA, static_cast(&devpar)) == -1) -#else - errno = ENOSYS; -#endif /* ACE_HAS_TERMIOS */ - return -1; - - switch (cmd) - { - case SETPARAMS: - switch (arg->baudrate) - { -#if defined (B0) - case 0: newbaudrate = B0; break; -#endif /* B0 */ -#if defined (B50) - case 50: newbaudrate = B50; break; -#endif /* B50 */ -#if defined (B75) - case 75: newbaudrate = B75; break; -#endif /* B75 */ -#if defined (B110) - case 110: newbaudrate = B110; break; -#endif /* B110 */ -#if defined (B134) - case 134: newbaudrate = B134; break; -#endif /* B134 */ -#if defined (B150) - case 150: newbaudrate = B150; break; -#endif /* B150 */ -#if defined (B200) - case 200: newbaudrate = B200; break; -#endif /* B200 */ -#if defined (B300) - case 300: newbaudrate = B300; break; -#endif /* B300 */ -#if defined (B600) - case 600: newbaudrate = B600; break; -#endif /* B600 */ -#if defined (B1200) - case 1200: newbaudrate = B1200; break; -#endif /* B1200 */ -#if defined (B1800) - case 1800: newbaudrate = B1800; break; -#endif /* B1800 */ -#if defined (B2400) - case 2400: newbaudrate = B2400; break; -#endif /* B2400 */ -#if defined (B4800) - case 4800: newbaudrate = B4800; break; -#endif /* B4800 */ -#if defined (B9600) - case 9600: newbaudrate = B9600; break; -#endif /* B9600 */ -#if defined (B19200) - case 19200: newbaudrate = B19200; break; -#endif /* B19200 */ -#if defined (B38400) - case 38400: newbaudrate = B38400; break; -#endif /* B38400 */ -#if defined (B56000) - case 56000: newbaudrate = B56000; break; -#endif /* B56000 */ -#if defined (B57600) - case 57600: newbaudrate = B57600; break; -#endif /* B57600 */ -#if defined (B76800) - case 76800: newbaudrate = B76800; break; -#endif /* B76800 */ -#if defined (B115200) - case 115200: newbaudrate = B115200; break; -#endif /* B115200 */ -#if defined (B128000) - case 128000: newbaudrate = B128000; break; -#endif /* B128000 */ -#if defined (B153600) - case 153600: newbaudrate = B153600; break; -#endif /* B153600 */ -#if defined (B230400) - case 230400: newbaudrate = B230400; break; -#endif /* B230400 */ -#if defined (B307200) - case 307200: newbaudrate = B307200; break; -#endif /* B307200 */ -#if defined (B256000) - case 256000: newbaudrate = B256000; break; -#endif /* B256000 */ -#if defined (B460800) - case 460800: newbaudrate = B460800; break; -#endif /* B460800 */ -#if defined (B500000) - case 500000: newbaudrate = B500000; break; -#endif /* B500000 */ -#if defined (B576000) - case 576000: newbaudrate = B576000; break; -#endif /* B576000 */ -#if defined (B921600) - case 921600: newbaudrate = B921600; break; -#endif /* B921600 */ -#if defined (B1000000) - case 1000000: newbaudrate = B1000000; break; -#endif /* B1000000 */ -#if defined (B1152000) - case 1152000: newbaudrate = B1152000; break; -#endif /* B1152000 */ -#if defined (B1500000) - case 1500000: newbaudrate = B1500000; break; -#endif /* B1500000 */ -#if defined (B2000000) - case 2000000: newbaudrate = B2000000; break; -#endif /* B2000000 */ -#if defined (B2500000) - case 2500000: newbaudrate = B2500000; break; -#endif /* B2500000 */ -#if defined (B3000000) - case 3000000: newbaudrate = B3000000; break; -#endif /* B3000000 */ -#if defined (B3500000) - case 3500000: newbaudrate = B3500000; break; -#endif /* B3500000 */ -#if defined (B4000000) - case 4000000: newbaudrate = B4000000; break; -#endif /* B4000000 */ - default: - return -1; - } - -#if defined (ACE_HAS_TERMIOS) - // Can you really have different input and output baud rates?! - if (cfsetospeed (&devpar, newbaudrate) == -1) - return -1; - if (cfsetispeed (&devpar, newbaudrate) == -1) - return -1; -#else - devpar.c_cflag &= ~CBAUD; -# if defined (CBAUDEX) - devpar.c_cflag &= ~CBAUDEX; -# endif /* CBAUDEX */ - devpar.c_cflag |= newbaudrate; -#endif /* ACE_HAS_TERMIOS */ - - devpar.c_cflag &= ~CSIZE; - switch (arg->databits) - { - case 5: - devpar.c_cflag |= CS5; - break; - case 6: - devpar.c_cflag |= CS6; - break; - case 7: - devpar.c_cflag |= CS7; - break; - case 8: - devpar.c_cflag |= CS8; - break; - default: - return -1; - } - - switch (arg->stopbits) - { - case 1: - devpar.c_cflag &= ~CSTOPB; - break; - case 2: - devpar.c_cflag |= CSTOPB; - break; - default: - return -1; - } - - if (arg->paritymode) - { - if (ACE_OS::strcasecmp (arg->paritymode, ACE_TTY_IO_ODD) == 0) - { - devpar.c_cflag |= PARENB; - devpar.c_cflag |= PARODD; - devpar.c_iflag &= ~IGNPAR; - devpar.c_iflag |= INPCK | PARMRK; - } - else if (ACE_OS::strcasecmp (arg->paritymode, ACE_TTY_IO_EVEN) == 0) - { - devpar.c_cflag |= PARENB; - devpar.c_cflag &= ~PARODD; - devpar.c_iflag &= ~IGNPAR; - devpar.c_iflag |= INPCK | PARMRK; - } - else if (ACE_OS::strcasecmp (arg->paritymode, ACE_TTY_IO_NONE) == 0) - { - devpar.c_cflag &= ~PARENB; - } - else - { - return -1; - } - } - else - { - devpar.c_cflag &= ~PARENB; - } - -#if defined (CNEW_RTSCTS) - if ((arg->ctsenb) || (arg->rtsenb)) // Enable RTS/CTS protocol - devpar.c_cflag |= CNEW_RTSCTS; - else - devpar.c_cflag &= ~CNEW_RTSCTS; -#elif defined (CRTSCTS) - if ((arg->ctsenb) || (arg->rtsenb)) // Enable RTS/CTS protocol - devpar.c_cflag |= CRTSCTS; - else - devpar.c_cflag &= ~CRTSCTS; -#endif /* NEW_RTSCTS || CRTSCTS */ - -#if defined (CREAD) - // Enable/disable receiver - if (arg->rcvenb) - devpar.c_cflag |= CREAD; - else - devpar.c_cflag &= ~CREAD; -#endif /* CREAD */ - -#if defined (HUPCL) - // Cause DTR to drop after port close. - devpar.c_cflag |= HUPCL; -#endif /* HUPCL */ - -#if defined (CLOCAL) - // If device is not a modem set to local device. - if (arg->modem) - devpar.c_cflag &= ~CLOCAL; - else - devpar.c_cflag |= CLOCAL; -#endif /* CLOCAL */ - - if (arg->databits < 8) - devpar.c_iflag |= ISTRIP; - -#if defined (IGNBRK) - // If device is not a modem set to ignore break points - if(arg->modem) - devpar.c_iflag &= ~IGNBRK; - else - devpar.c_iflag |= IGNBRK; -#endif /* IGNBRK */ - -#if defined (IXOFF) - // Enable/disable software flow control on input - if (arg->xinenb) - devpar.c_iflag |= IXOFF; - else - devpar.c_iflag &= ~IXOFF; -#endif /* IXOFF */ - -#if defined (IXON) - // Enable/disable software flow control on output - if (arg->xoutenb) - devpar.c_iflag |= IXON; - else - devpar.c_iflag &= ~IXON; -#endif /* IXON */ - -#if defined (ICANON) - // Enable noncanonical input processing mode - devpar.c_lflag &= ~ICANON; -#endif /* ICANON */ - -#if defined (ECHO) - // Disable echoing of input characters - devpar.c_lflag &= ~ECHO; -#endif /* ECHO */ - -#if defined (ECHOE) - // Disable echoing erase chareacter as BS-SP-BS - devpar.c_lflag &= ~ECHOE; -#endif /* ECHOE */ - -#if defined (ISIG) - // Disable SIGINTR, SIGSUSP, SIGDSUSP and SIGQUIT signals - devpar.c_lflag &= ~ISIG; -#endif /* ISIG */ - -#if defined (OPOST) - // Disable post-processing of output data - devpar.c_oflag &= ~OPOST; -#endif /* OPOST */ - - if (arg->readtimeoutmsec < 0) - { - // Settings for infinite timeout. - devpar.c_cc[VTIME] = 0; - // In case of infinite timeout [VMIN] must be at least 1. - if (arg->readmincharacters > UCHAR_MAX) - devpar.c_cc[VMIN] = UCHAR_MAX; - else if (arg->readmincharacters < 1) - devpar.c_cc[VMIN] = 1; - else - devpar.c_cc[VMIN] = static_cast(arg->readmincharacters); - } - else - { - devpar.c_cc[VTIME] = static_cast(arg->readtimeoutmsec / 100); - - if (arg->readmincharacters > UCHAR_MAX) - devpar.c_cc[VMIN] = UCHAR_MAX; - else if (arg->readmincharacters < 1) - devpar.c_cc[VMIN] = 0; - else - devpar.c_cc[VMIN] = static_cast(arg->readmincharacters); - } - -#if defined (TIOCMGET) - int status; - this->ACE_IO_SAP::control (TIOCMGET, &status); - - if (arg->dtrdisable) - status &= ~TIOCM_DTR; - else - status |= TIOCM_DTR; - - this->ACE_IO_SAP::control (TIOCMSET, &status); -#endif /* definded (TIOCMGET) */ - -#if defined (ACE_HAS_TERMIOS) - return tcsetattr (get_handle (), TCSANOW, &devpar); -#elif defined (TCSETS) - return this->ACE_IO_SAP::control (TCSETS, static_cast(&devpar)); -#elif defined (TCSETA) - return this->ACE_IO_SAP::control (TCSETA, static_cast(&devpar)); -#else - errno = ENOSYS; - return -1; -#endif /* ACE_HAS_TERMIOS */ - - case GETPARAMS: - return -1; // Not yet implemented. - default: - return -1; // Wrong cmd. - } -#elif defined (ACE_WIN32) - DCB dcb; - dcb.DCBlength = sizeof dcb; - if (!::GetCommState (this->get_handle (), &dcb)) - { - ACE_OS::set_errno_to_last_error (); - return -1; - } - - COMMTIMEOUTS timeouts; - if (!::GetCommTimeouts (this->get_handle(), &timeouts)) - { - ACE_OS::set_errno_to_last_error (); - return -1; - } - - switch (cmd) - { - case SETPARAMS: - dcb.BaudRate = arg->baudrate; - - switch (arg->databits) - { - case 4: - case 5: - case 6: - case 7: - case 8: - dcb.ByteSize = arg->databits; - break; - default: - return -1; - } - - switch (arg->stopbits) - { - case 1: - dcb.StopBits = ONESTOPBIT; - break; - case 2: - dcb.StopBits = TWOSTOPBITS; - break; - default: - return -1; - } - - if (arg->paritymode) - { - dcb.fParity = TRUE; - if (ACE_OS::strcasecmp (arg->paritymode, ACE_TTY_IO_ODD) == 0) - dcb.Parity = ODDPARITY; - else if (ACE_OS::strcasecmp (arg->paritymode, ACE_TTY_IO_EVEN) == 0) - dcb.Parity = EVENPARITY; - else if (ACE_OS::strcasecmp (arg->paritymode, ACE_TTY_IO_NONE) == 0) - dcb.Parity = NOPARITY; - else if (ACE_OS::strcasecmp (arg->paritymode, ACE_TTY_IO_MARK) == 0) - dcb.Parity = MARKPARITY; - else if (ACE_OS::strcasecmp (arg->paritymode, ACE_TTY_IO_SPACE) == 0) - dcb.Parity = SPACEPARITY; - else - return -1; - } - else - { - dcb.fParity = FALSE; - dcb.Parity = NOPARITY; - } - - // Enable/disable RTS protocol. - switch (arg->rtsenb) - { - case 1: - dcb.fRtsControl = RTS_CONTROL_ENABLE; - break; - case 2: - dcb.fRtsControl = RTS_CONTROL_HANDSHAKE; - break; - case 3: - dcb.fRtsControl = RTS_CONTROL_TOGGLE; - break; - default: - dcb.fRtsControl = RTS_CONTROL_DISABLE; - } - - // Enable/disable CTS protocol. - if (arg->ctsenb) - dcb.fOutxCtsFlow = TRUE; - else - dcb.fOutxCtsFlow = FALSE; - - // Enable/disable DSR protocol. - if (arg->dsrenb) - dcb.fOutxDsrFlow = TRUE; - else - dcb.fOutxDsrFlow = FALSE; - - // Disable/enable DTR protocol - if (arg->dtrdisable) - dcb.fDtrControl = DTR_CONTROL_DISABLE; - else - dcb.fDtrControl = DTR_CONTROL_ENABLE; - - // Enable/disable software flow control on input - if (arg->xinenb) - dcb.fInX = TRUE; - else - dcb.fInX = FALSE; - - // Enable/disable software flow control on output - if (arg->xoutenb) - dcb.fOutX = TRUE; - else - dcb.fOutX = FALSE; - - // Always set limits unless set to negative to use default. - if (arg->xonlim >= 0) - dcb.XonLim = static_cast(arg->xonlim); - if (arg->xofflim >= 0) - dcb.XoffLim = static_cast(arg->xofflim); - - dcb.fAbortOnError = FALSE; - dcb.fErrorChar = FALSE; - dcb.fNull = FALSE; - dcb.fBinary = TRUE; - - if (!::SetCommState (this->get_handle (), &dcb)) - { - ACE_OS::set_errno_to_last_error (); - return -1; - } - - if (arg->readtimeoutmsec < 0) - { - // Settings for infinite timeout. - timeouts.ReadIntervalTimeout = 0; - timeouts.ReadTotalTimeoutMultiplier = 0; - timeouts.ReadTotalTimeoutConstant = 0; - } - else if (arg->readtimeoutmsec == 0) - { - // Return immediately if no data in the input buffer. - timeouts.ReadIntervalTimeout = MAXDWORD; - timeouts.ReadTotalTimeoutMultiplier = 0; - timeouts.ReadTotalTimeoutConstant = 0; - } - else - { - // Wait for specified timeout for char to arrive before returning. - timeouts.ReadIntervalTimeout = MAXDWORD; - timeouts.ReadTotalTimeoutMultiplier = MAXDWORD; - timeouts.ReadTotalTimeoutConstant = arg->readtimeoutmsec; - } - - if (!::SetCommTimeouts (this->get_handle (), &timeouts)) - { - ACE_OS::set_errno_to_last_error (); - return -1; - } - - return 0; - - case GETPARAMS: - arg->baudrate = dcb.BaudRate; - - switch (dcb.ByteSize) - { - case 4: - case 5: - case 6: - case 7: - case 8: - arg->databits = dcb.ByteSize; - break; - default: - return -1; - } - - switch (dcb.StopBits) - { - case ONESTOPBIT: - arg->stopbits = 1; - break; - case TWOSTOPBITS: - arg->stopbits = 2; - break; - default: - return -1; - } - - if (!dcb.fParity) - { - arg->paritymode = ACE_TTY_IO_NONE; - } - else - { - switch (dcb.Parity) - { - case ODDPARITY: - arg->paritymode = ACE_TTY_IO_ODD; - break; - case EVENPARITY: - arg->paritymode = ACE_TTY_IO_EVEN; - break; - case NOPARITY: - arg->paritymode = ACE_TTY_IO_NONE; - break; - case MARKPARITY: - arg->paritymode = ACE_TTY_IO_MARK; - break; - case SPACEPARITY: - arg->paritymode = ACE_TTY_IO_SPACE; - break; - default: - return -1; - } - } - - // Enable/disable RTS protocol. - switch (dcb.fRtsControl) - { - case RTS_CONTROL_ENABLE: - arg->rtsenb = 1; - break; - case RTS_CONTROL_HANDSHAKE: - arg->rtsenb = 2; - break; - case RTS_CONTROL_TOGGLE: - arg->rtsenb = 3; - break; - case RTS_CONTROL_DISABLE: - arg->rtsenb = 0; - break; - default: - return -1; - } - - // Enable/disable CTS protocol. - if (dcb.fOutxCtsFlow) - arg->ctsenb = true; - else - arg->ctsenb = false; - - // Enable/disable DSR protocol. - if (dcb.fOutxDsrFlow) - arg->dsrenb = true; - else - arg->dsrenb = false; - - // Disable/enable DTR protocol - // Attention: DTR_CONTROL_HANDSHAKE is not supported. - switch (dcb.fDtrControl) - { - case DTR_CONTROL_DISABLE: - arg->dtrdisable = true; - break; - case DTR_CONTROL_ENABLE: - arg->dtrdisable = false; - break; - default: - return -1; - } - - // Enable/disable software flow control on input - if (dcb.fInX) - arg->xinenb = true; - else - arg->xinenb = false; - - // Enable/disable software flow control on output - if (dcb.fOutX) - arg->xoutenb = true; - else - arg->xoutenb = false; - - arg->xonlim = static_cast(dcb.XonLim); - arg->xofflim = static_cast(dcb.XoffLim); - - if (timeouts.ReadIntervalTimeout == 0 && - timeouts.ReadTotalTimeoutMultiplier == 0 && - timeouts.ReadTotalTimeoutConstant == 0) - arg->readtimeoutmsec = -1; - else - arg->readtimeoutmsec = timeouts.ReadTotalTimeoutConstant; - - return 0; - - default: - return -1; // Wrong cmd. - - } // arg switch -#else - ACE_UNUSED_ARG (cmd); - ACE_UNUSED_ARG (arg); - ACE_NOTSUP_RETURN (-1); -#endif /* ACE_HAS_TERMIOS || ACE_HAS_TERMIO */ -} - -#if defined (ACE_NEEDS_DEV_IO_CONVERSION) -ACE_TTY_IO::operator ACE_DEV_IO &() -{ - return static_cast(*this); -} -#endif /* ACE_NEEDS_DEV_IO_CONVERSION */ - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/TTY_IO.h b/deps/acelite/ace/TTY_IO.h deleted file mode 100644 index 860184d7d..000000000 --- a/deps/acelite/ace/TTY_IO.h +++ /dev/null @@ -1,113 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file TTY_IO.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_TTY_IO_H -#define ACE_TTY_IO_H - -#include "ace/DEV_IO.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_TTY_IO - * - * @brief Class definitions for platform specific TTY features. - * - * This class represents an example interface for a specific - * device (a serial line). It extends the capability of the - * underlying DEV_IO class by adding a control method that takes - * a special structure (Serial_Params) as argument to allow a - * comfortable user interface (away from that annoying termios - * structure, which is very specific to UNIX). - */ -class ACE_Export ACE_TTY_IO : public ACE_DEV_IO -{ -public: - ACE_TTY_IO (void); - - enum Control_Mode - { - SETPARAMS, ///< Set control parameters. - GETPARAMS ///< Get control parameters. - }; - - struct ACE_Export Serial_Params - { - Serial_Params (void); - - /** Specifies the baudrate at which the communication port operates. */ - int baudrate; - /** Specifies the minimum number of bytes in input buffer before XON char - is sent. Negative value indicates that default value should - be used (Win32). */ - int xonlim; - /** Specifies the maximum number of bytes in input buffer before XOFF char - is sent. Negative value indicates that default value should - be used (Win32). */ - int xofflim; - /** Specifies the minimum number of characters for non-canonical - read (POSIX). */ - unsigned int readmincharacters; - /** Specifies the time to wait before returning from read. Negative value - means infinite timeout. */ - int readtimeoutmsec; - /** Specifies the parity mode. POSIX supports "none", "even" and - "odd" parity. Additionally Win32 supports "mark" and "space" - parity modes. */ - const char *paritymode; - /** Enable & set CTS mode. Note that RTS & CTS are enabled/disabled - together on some systems (RTS/CTS is enabled if either - ctsenb or rtsenb is set). */ - bool ctsenb; - /** Enable & set RTS mode. Note that RTS & CTS are enabled/disabled - together on some systems (RTS/CTS is enabled if either - ctsenb or rtsenb is set). - - 0 = Disable RTS. - - 1 = Enable RTS. - - 2 = Enable RTS flow-control handshaking (Win32). - - 3 = Specifies that RTS line will be high if bytes are available - for transmission. After transmission RTS will be low (Win32). */ - unsigned char rtsenb; - /** Enable/disable software flow control on input. */ - bool xinenb; - /** Enable/disable software flow control on output. */ - bool xoutenb; - /** Specifies if device is a modem (POSIX). If not set modem status - lines are ignored. */ - bool modem; - /** Enable/disable receiver (POSIX). */ - bool rcvenb; - /** Controls whether DSR is disabled or enabled (Win32). */ - bool dsrenb; - /** Controls whether DTR is disabled or enabled. */ - bool dtrdisable; - /** Data bits. Valid values 5, 6, 7 and 8 data bits. - Additionally Win32 supports 4 data bits. */ - unsigned char databits; - /** Stop bits. Valid values are 1 and 2. */ - unsigned char stopbits; - }; - - /** Interface for reading/writing serial device parameters. */ - int control (Control_Mode cmd, Serial_Params *arg) const; - -#if defined (ACE_NEEDS_DEV_IO_CONVERSION) - /** This is necessary to pass ACE_TTY_IO as parameter to DEV_Connector. */ - operator ACE_DEV_IO &(); -#endif /* ACE_NEEDS_DEV_IO_CONVERSION */ -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_TTY_IO_H */ diff --git a/deps/acelite/ace/Task.cpp b/deps/acelite/ace/Task.cpp deleted file mode 100644 index 17acc652f..000000000 --- a/deps/acelite/ace/Task.cpp +++ /dev/null @@ -1,293 +0,0 @@ -#include "ace/Task.h" -#include "ace/Module.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Task.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Task_Base::ACE_Task_Base (ACE_Thread_Manager *thr_man) - : thr_count_ (0), - thr_mgr_ (thr_man), - flags_ (0), - grp_id_ (-1) -#if !(defined (ACE_TANDEM_T1248_PTHREADS) || defined (ACE_THREAD_T_IS_A_STRUCT)) - ,last_thread_id_ (0) -#endif /* ! ACE_TANDEM_T1248_PTHREADS || ACE_THREAD_T_IS_A_STRUCT */ -{ -#if defined (ACE_TANDEM_T1248_PTHREADS) || defined (ACE_THREAD_T_IS_A_STRUCT) - ACE_OS::memset( &this->last_thread_id_, '\0', sizeof( this->last_thread_id_ )); -#endif /* ACE_TANDEM_T1248_PTHREADS || ACE_THREAD_T_IS_A_STRUCT */ -} - -ACE_Task_Base::~ACE_Task_Base (void) -{ -} - -/// Default ACE_Task service routine -int -ACE_Task_Base::svc (void) -{ - ACE_TRACE ("ACE_Task_Base::svc"); - return 0; -} - -/// Default ACE_Task open routine -int -ACE_Task_Base::open (void *) -{ - ACE_TRACE ("ACE_Task_Base::open"); - return 0; -} - -/// Default ACE_Task close routine -int -ACE_Task_Base::close (u_long) -{ - ACE_TRACE ("ACE_Task_Base::close"); - return 0; -} - -/// Forward the call to close() so that existing applications don't -/// break. -int -ACE_Task_Base::module_closed (void) -{ - return this->close (1); -} - -/// Default ACE_Task put routine. -int -ACE_Task_Base::put (ACE_Message_Block *, ACE_Time_Value *) -{ - ACE_TRACE ("ACE_Task_Base::put"); - return 0; -} - -/// Wait for all threads running in a task to exit. -int -ACE_Task_Base::wait (void) -{ - ACE_TRACE ("ACE_Task_Base::wait"); - - // If we don't have a thread manager, we probably were never - // activated. - if (this->thr_mgr () != 0) - return this->thr_mgr ()->wait_task (this); - else - return 0; -} - -/// Suspend a task. -int -ACE_Task_Base::suspend (void) -{ - ACE_TRACE ("ACE_Task_Base::suspend"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - if (this->thr_count_ > 0) - return this->thr_mgr_->suspend_task (this); - - return 0; -} - -/// Resume a suspended task. -int -ACE_Task_Base::resume (void) -{ - ACE_TRACE ("ACE_Task_Base::resume"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - if (this->thr_count_ > 0) - return this->thr_mgr_->resume_task (this); - - return 0; -} - -int -ACE_Task_Base::activate (long flags, - int n_threads, - int force_active, - long priority, - int grp_id, - ACE_Task_Base *task, - ACE_hthread_t thread_handles[], - void *stack[], - size_t stack_size[], - ACE_thread_t thread_ids[], - const char* thr_name[]) -{ - ACE_TRACE ("ACE_Task_Base::activate"); - -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1); - - // If the task passed in is zero, we will use - if (task == 0) - task = this; - - if (this->thr_count_ > 0 && force_active == 0) - return 1; // Already active. - else - { - if ((this->thr_count_ > 0 || grp_id == -1) && - this->grp_id_ != -1) - // If we're joining an existing group of threads then make - // sure to (re)use its group id. - grp_id = this->grp_id_; - else if (grp_id != -1) - // make sure to reset the cached grp_id - this->grp_id_ = -1; - this->thr_count_ += n_threads; - } - - // Use the ACE_Thread_Manager singleton if we're running as an - // active object and the caller didn't supply us with a - // Thread_Manager. - if (this->thr_mgr_ == 0) -# if defined (ACE_THREAD_MANAGER_LACKS_STATICS) - this->thr_mgr_ = ACE_THREAD_MANAGER_SINGLETON::instance (); -# else /* ! ACE_THREAD_MANAGER_LACKS_STATICS */ - this->thr_mgr_ = ACE_Thread_Manager::instance (); -# endif /* ACE_THREAD_MANAGER_LACKS_STATICS */ - - int grp_spawned = -1; - if (thread_ids == 0) - // Thread Ids were not specified - grp_spawned = - this->thr_mgr_->spawn_n (n_threads, - &ACE_Task_Base::svc_run, - (void *) this, - flags, - priority, - grp_id, - task, - thread_handles, - stack, - stack_size, - thr_name); - else - // thread names were specified - grp_spawned = - this->thr_mgr_->spawn_n (thread_ids, - n_threads, - &ACE_Task_Base::svc_run, - (void *) this, - flags, - priority, - grp_id, - stack, - stack_size, - thread_handles, - task, - thr_name); - if (grp_spawned == -1) - { - // If spawn_n fails, restore original thread count. - this->thr_count_ -= n_threads; - return -1; - } - - if (this->grp_id_ == -1) - this->grp_id_ = grp_spawned; - -#if defined(ACE_TANDEM_T1248_PTHREADS) || defined (ACE_THREAD_T_IS_A_STRUCT) - ACE_OS::memcpy( &this->last_thread_id_, '\0', sizeof(this->last_thread_id_)); -#else - this->last_thread_id_ = 0; // Reset to prevent inadvertant match on ID -#endif /* ACE_TANDEM_T1248_PTHREADS || ACE_THREAD_T_IS_A_STRUCT */ - - return 0; - -#else - { - // Keep the compiler from complaining. - ACE_UNUSED_ARG (flags); - ACE_UNUSED_ARG (n_threads); - ACE_UNUSED_ARG (force_active); - ACE_UNUSED_ARG (priority); - ACE_UNUSED_ARG (grp_id); - ACE_UNUSED_ARG (task); - ACE_UNUSED_ARG (thread_handles); - ACE_UNUSED_ARG (stack); - ACE_UNUSED_ARG (stack_size); - ACE_UNUSED_ARG (thread_ids); - ACE_UNUSED_ARG (thr_name); - ACE_NOTSUP_RETURN (-1); - } -#endif /* ACE_MT_SAFE */ -} - -void -ACE_Task_Base::cleanup (void *object, void *) -{ - ACE_Task_Base *t = (ACE_Task_Base *) object; - - // The thread count must be decremented first in case the - // hook does something crazy like "delete this". - { - ACE_MT (ACE_GUARD (ACE_Thread_Mutex, ace_mon, t->lock_)); - t->thr_count_--; - if (0 == t->thr_count_) - t->last_thread_id_ = ACE_Thread::self (); - } - - // @@ Is it possible to pass in the exit status somehow? - t->close (); - // t is undefined here. close() could have deleted it. -} - - -#if defined (ACE_HAS_SIG_C_FUNC) -extern "C" void -ACE_Task_Base_cleanup (void *object, void *) -{ - ACE_Task_Base::cleanup (object, 0); -} -#endif /* ACE_HAS_SIG_C_FUNC */ - -ACE_THR_FUNC_RETURN -ACE_Task_Base::svc_run (void *args) -{ - ACE_TRACE ("ACE_Task_Base::svc_run"); - - ACE_Task_Base *t = (ACE_Task_Base *) args; - - // Register ourself with our 's thread exit hook - // mechanism so that our close() hook will be sure to get invoked - // when this thread exits. - -#if defined ACE_HAS_SIG_C_FUNC - t->thr_mgr ()->at_exit (t, ACE_Task_Base_cleanup, 0); -#else - t->thr_mgr ()->at_exit (t, ACE_Task_Base::cleanup, 0); -#endif /* ACE_HAS_SIG_C_FUNC */ - - ACE_THR_FUNC_RETURN status; - // Call the Task's svc() hook method. - int const svc_status = t->svc (); - -#if defined (ACE_HAS_INTEGRAL_TYPE_THR_FUNC_RETURN) - // Reinterpret case between integral types is not mentioned in the C++ spec - status = static_cast (svc_status); -#else - status = reinterpret_cast (svc_status); -#endif /* ACE_HAS_INTEGRAL_TYPE_THR_FUNC_RETURN */ - -// If we changed this zero change the other if in OS.cpp Thread_Adapter::invoke -#if 1 - // Call the close> hook. - ACE_Thread_Manager *thr_mgr_ptr = t->thr_mgr (); - - // This calls the Task->close () hook. - t->cleanup (t, 0); - - // This prevents a second invocation of the cleanup code - // (called later by . - thr_mgr_ptr->at_exit (t, 0, 0); -#endif - return status; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Task.h b/deps/acelite/ace/Task.h deleted file mode 100644 index 51218fe04..000000000 --- a/deps/acelite/ace/Task.h +++ /dev/null @@ -1,301 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Task.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_TASK_H -#define ACE_TASK_H -#include /**/ "ace/pre.h" - -#include "ace/Service_Object.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Thread_Manager.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Task_Flags - * - * @brief These flags are used within the ACE_Task. - * - * These flags should be hidden within ACE_Task. Unfortunately, the - * HP/UX C++ compiler can't grok this... Fortunately, there's no - * code defined here, so we don't have to worry about multiple - * definitions. - */ -namespace ACE_Task_Flags -{ - enum - { - /// Identifies a Task as being the "reader" in a Module. - ACE_READER = 01, - /// Just flush data messages in the queue. - ACE_FLUSHDATA = 02, - /// Flush all messages in the Queue. - ACE_FLUSHALL = 04, - /// Flush read queue - ACE_FLUSHR = 010, - /// Flush write queue - ACE_FLUSHW = 020, - /// Flush both queues - ACE_FLUSHRW = 030 - }; -} - -/** - * @class ACE_Task_Base - * - * @brief Direct base class for the ACE_Task template. - * - * This class factors out the non-template code in order to - * reduce template bloat, as well as to make it possible for the - * ACE_Thread_Manager to store ACE_Task_Base *'s - * polymorphically. - */ -class ACE_Export ACE_Task_Base : public ACE_Service_Object -{ -public: - /// Constructor. - ACE_Task_Base (ACE_Thread_Manager * = 0); - - /// Destructor. - virtual ~ACE_Task_Base (void); - - // These methods should be overridden by subclasses if you'd like to - // provide -specific initialization and termination behavior. - - /// Hook called to initialize a task and prepare it for execution. - /// @a args can be used to pass arbitrary information into . - virtual int open (void *args = 0); - - /** - * Hook called from ACE_Thread_Exit when during thread exit and from - * the default implementation of @c module_closed(). In general, this - * method shouldn't be called directly by an application, - * particularly if the Task is running as an Active Object. - * Instead, a special message should be passed into the Task via - * the put() method defined below, and the svc() method should - * interpret this as a flag to shut down the Task. - */ - virtual int close (u_long flags = 0); - - /** - * Hook called during ACE_Module::close(). The default - * implementation calls forwards the call to close(1). Please - * notice the changed value of the default argument of close(). - * This allows tasks to differ between the call has been originated - * from ACE_Thread_Exit or from module_closed(). Be aware that - * close(0) will be also called when a thread associated with the - * ACE_Task instance exits. - */ - virtual int module_closed (void); - - // = Immediate and deferred processing methods, respectively. - - // These methods should be overridden by subclasses if you'd like to - // provide -specific message processing behavior. - - /// A hook method that can be used to pass a message to a - /// task, where it can be processed immediately or queued for subsequent - /// processing in the svc() hook method. - virtual int put (ACE_Message_Block *, ACE_Time_Value * = 0); - - /// Run by a daemon thread to handle deferred processing. - virtual int svc (void); - - // = Active object activation method. - /** - * Turn the task into an active object, i.e., having @a n_threads of - * control, all running at the @a priority level (see below) with the - * same @a grp_id, all of which invoke . Returns -1 if - * failure occurs, returns 1 if Task is already an active object and - * @a force_active is false (i.e., do *not* create a new thread in - * this case), and returns 0 if Task was not already an active - * object and a thread is created successfully or thread is an - * active object and @a force_active is true. Note that if - * @a force_active is true and there are already threads spawned in - * this , the @a grp_id parameter is ignored and the @a grp_id - * of any newly activated thread(s) will inherit the existing - * @a grp_id of the existing thread(s) in the . - * - * The <{flags}> are a bitwise-OR of the following: - * = BEGIN - * THR_CANCEL_DISABLE, THR_CANCEL_ENABLE, THR_CANCEL_DEFERRED, - * THR_CANCEL_ASYNCHRONOUS, THR_BOUND, THR_NEW_LWP, THR_DETACHED, - * THR_SUSPENDED, THR_DAEMON, THR_JOINABLE, THR_SCHED_FIFO, - * THR_SCHED_RR, THR_SCHED_DEFAULT, THR_EXPLICIT_SCHED, - * THR_SCOPE_SYSTEM, THR_SCOPE_PROCESS - * = END - * If THR_SCHED_INHERIT is not desirable, applications should - * specifically pass in THR_EXPLICIT_SCHED. - * - * - * By default, or if <{priority}> is set to - * ACE_DEFAULT_THREAD_PRIORITY, an "appropriate" priority value for - * the given scheduling policy (specified in <{flags}>, e.g., - * ) is used. This value is calculated - * dynamically, and is the median value between the minimum and - * maximum priority values for the given policy. If an explicit - * value is given, it is used. Note that actual priority values are - * EXTREMEMLY implementation-dependent, and are probably best - * avoided. - * - * If @a thread_handles != 0 it is assumed to be an array of @a n - * thread_handles that will be assigned the values of the thread - * handles being spawned. Returns -1 on failure (@c errno will - * explain...), otherwise returns the group id of the threads. - * - * Assigning @a task allows you to associate the newly spawned - * threads with an instance of ACE_Task_Base. If @a task == 0, then - * the new threads are associated automatically with @c this - * ACE_Task_Base. Setting the @a task argument to value other than - * @c this makes the thread manipulating methods, such as wait(), - * suspend(), resume(), useless. Threads spawned with user - * specified @a task value must therefore be manipulated thru - * ACE_Thread_Manager directly. - * - * If @a stack != 0 it is assumed to be an array of @a n pointers to - * the base of the stacks to use for the threads being spawned. - * Likewise, if @a stack_size != 0 it is assumed to be an array of - * @a n values indicating how big each of the corresponding @a stacks - * are. - * - * - */ - virtual int activate (long flags = THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED, - int n_threads = 1, - int force_active = 0, - long priority = ACE_DEFAULT_THREAD_PRIORITY, - int grp_id = -1, - ACE_Task_Base *task = 0, - ACE_hthread_t thread_handles[] = 0, - void *stack[] = 0, - size_t stack_size[] = 0, - ACE_thread_t thread_ids[] = 0, - const char* thr_name[] = 0); - - /** - * Block until there are no more threads running in this task. - * This method will not wait for either detached or daemon threads; - * the threads must have been spawned with the @c THR_JOINABLE flag. - * Upon successful completion, the threads have been joined, so further - * attempts to join with any of the waited-for threads will fail. - * - * @retval 0 Success. - * @retval -1 Failure (consult errno for further information). - */ - virtual int wait (void); - - // = Suspend/resume a Task. - - // Note that these methods are not portable and should be avoided - // since they are inherently error-prone to use. They are only here - // for (the rare) applications that know how to use them correctly. - /// Suspend a task. - virtual int suspend (void); - /// Resume a suspended task. - virtual int resume (void); - - /// Get the current group id. - int grp_id (void) const; - - /// Set the current group id. - void grp_id (int); - - /// Get the thread manager associated with this Task. - ACE_Thread_Manager *thr_mgr (void) const; - - /// Set the thread manager associated with this Task. - void thr_mgr (ACE_Thread_Manager *); - - /// True if queue is a reader, else false. - int is_reader (void) const; - - /// True if queue is a writer, else false. - int is_writer (void) const; - - /** - * Returns the number of threads currently running within a task. - * If we're a passive object this value is 0, else it's greater than - * 0. - */ - size_t thr_count (void) const; - - /** - * Returns the thread ID of the thread whose exit caused this object's - * thread count to be decremented to 0. - * - * When a thread spawned in the context of this object (using activate()) - * returns from its svc() method ACE calls the close() hook. Before it does - * so, it decrements the number of active threads. If the number of threads - * is decremented to 0, the thread ID of the current thread is stored for - * access by this method. If the returned thread ID matches the calling - * thread's ID, the calling thread knows that there are no other threads - * still active in the ACE_Task. - * - * @retval ACE_thread_t of the last thread to close. 0 if the last thread - * is not yet known; for example, if no threads are active, or if - * multiple threads are active. - */ - ACE_thread_t last_thread (void) const; - - /// Routine that runs the service routine as a daemon thread. - static ACE_THR_FUNC_RETURN svc_run (void *); - - /// Cleanup hook that is called when a thread exits to gracefully - /// shutdown an ACE_Task. - static void cleanup (void *object, void *params); - -protected: - /** - * Count of the number of threads running within the task. If this - * value is greater than 0 then we're an active object and the value - * of is the number of active threads at this instant. - * If the value == 0, then we're a passive object. - */ - size_t thr_count_; - - /// Multi-threading manager. - ACE_Thread_Manager *thr_mgr_; - - /// ACE_Task flags. - u_long flags_; - - /// This maintains the group id of the Task. - int grp_id_; - -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - /// Protect the state of a Task during concurrent operations, but - /// only if we're configured as MT safe... - mutable ACE_Thread_Mutex lock_; -#endif /* ACE_MT_SAFE */ - - /// Holds the thread ID of the last thread to exit svc() in this object. - ACE_thread_t last_thread_id_; -private: - - // = Disallow these operations. - ACE_Task_Base &operator= (const ACE_Task_Base &); - ACE_Task_Base (const ACE_Task_Base &); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Task.inl" -#endif /* __ACE_INLINE__ */ - -// Include the ACE_Task templates classes at this point. -#include "ace/Task_T.h" - -#include /**/ "ace/post.h" -#endif /* ACE_TASK_H */ diff --git a/deps/acelite/ace/Task.inl b/deps/acelite/ace/Task.inl deleted file mode 100644 index 2d585d13b..000000000 --- a/deps/acelite/ace/Task.inl +++ /dev/null @@ -1,73 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Get the current group id. -ACE_INLINE int -ACE_Task_Base::grp_id (void) const -{ - ACE_TRACE ("ACE_Task_Base::grp_id"); - return this->grp_id_; -} - -// Set the current group id. - -ACE_INLINE void -ACE_Task_Base::grp_id (int identifier) -{ - ACE_TRACE ("ACE_Task_Base::grp_id"); - ACE_MT (ACE_GUARD (ACE_Thread_Mutex, ace_mon, this->lock_)); - - // Cache the group id in the task and then set it in the - // Thread_Manager, if there is one. - this->grp_id_ = identifier; - if (this->thr_mgr ()) - this->thr_mgr ()->set_grp (this, identifier); -} - -ACE_INLINE ACE_Thread_Manager * -ACE_Task_Base::thr_mgr (void) const -{ - ACE_TRACE ("ACE_Task_Base::thr_mgr"); - return this->thr_mgr_; -} - -ACE_INLINE void -ACE_Task_Base::thr_mgr (ACE_Thread_Manager *thr_mgr) -{ - ACE_TRACE ("ACE_Task_Base::thr_mgr"); - this->thr_mgr_ = thr_mgr; -} - -ACE_INLINE int -ACE_Task_Base::is_reader (void) const -{ - ACE_TRACE ("ACE_Task_Base::is_reader"); - return (ACE_BIT_ENABLED (this->flags_, ACE_Task_Flags::ACE_READER)); -} - -ACE_INLINE int -ACE_Task_Base::is_writer (void) const -{ - ACE_TRACE ("ACE_Task_Base::is_writer"); - return (ACE_BIT_DISABLED (this->flags_, ACE_Task_Flags::ACE_READER)); -} - -// Return the count of the current number of threads. -ACE_INLINE size_t -ACE_Task_Base::thr_count (void) const -{ - ACE_TRACE ("ACE_Task_Base::thr_count"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); - - return this->thr_count_; -} - -// Return the thread ID of the last thread to exit svc(). -ACE_INLINE ACE_thread_t -ACE_Task_Base::last_thread (void) const -{ - ACE_TRACE ("ACE_Task_Base::last_thread"); - return this->last_thread_id_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Task_Ex_T.cpp b/deps/acelite/ace/Task_Ex_T.cpp deleted file mode 100644 index 801c433ab..000000000 --- a/deps/acelite/ace/Task_Ex_T.cpp +++ /dev/null @@ -1,117 +0,0 @@ -#ifndef ACE_TASK_EX_T_CPP -#define ACE_TASK_EX_T_CPP - -#include "ace/Task_Ex_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Module.h" -#include "ace/Null_Condition.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Task_Ex_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tycc (ACE_Task_Ex) - -template void -ACE_Task_Ex::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Task_Ex::dump"); - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nthr_mgr_ = %x"), this->thr_mgr_)); - this->msg_queue_->dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_msg_queue_ = %d\n"), this->delete_msg_queue_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nflags = %x"), this->flags_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nmod_ = %x"), this->mod_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nnext_ = %x"), this->next_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\ngrp_id_ = %d"), this->grp_id_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nthr_count_ = %d"), this->thr_count_)); -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - this->lock_.dump (); -#endif /* ACE_MT_SAFE */ - - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -// If the user doesn't supply a ACE_Message_Queue_Ex pointer then we'll -// allocate one dynamically. Otherwise, we'll use the one they give. - -template -ACE_Task_Ex::ACE_Task_Ex (ACE_Thread_Manager *thr_man, - ACE_Message_Queue_Ex *mq) - : ACE_Task_Base (thr_man), - msg_queue_ (0), - delete_msg_queue_ (false), - mod_ (0), - next_ (0) -{ - ACE_TRACE ("ACE_Task_Ex::ACE_Task_Ex"); - - if (mq == 0) - { - ACE_NEW (mq, - (ACE_Message_Queue_Ex)); - this->delete_msg_queue_ = true; - } - - this->msg_queue_ = mq; -} - -template -ACE_Task_Ex::~ACE_Task_Ex (void) -{ - ACE_TRACE ("ACE_Task_Ex::~ACE_Task_Ex"); - if (this->delete_msg_queue_) - delete this->msg_queue_; - - // These assignments aren't strickly necessary but they help guard - // against odd race conditions... - this->delete_msg_queue_ = false; -} - -template ACE_Task * -ACE_Task_Ex::sibling (void) -{ - ACE_TRACE ("ACE_Task_Ex::sibling"); - /// @todo FIXME Need to impl ACE_Moudle to support ACE_Task as well. - /// Now always return 0 for sibling - return 0; -/* - if (this->mod_ == 0) - return 0; - else - return this->mod_->sibling (this); -*/ -} - -template const ACE_TCHAR * -ACE_Task_Ex::name (void) const -{ - ACE_TRACE ("ACE_Task_Ex::name"); - if (this->mod_ == 0) - return 0; - else - return this->mod_->name (); -} - -template ACE_Module * -ACE_Task_Ex::module (void) const -{ - ACE_TRACE ("ACE_Task_Ex::module"); - return this->mod_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_TASK_EX_T_CPP */ diff --git a/deps/acelite/ace/Task_Ex_T.h b/deps/acelite/ace/Task_Ex_T.h deleted file mode 100644 index 1f883dce7..000000000 --- a/deps/acelite/ace/Task_Ex_T.h +++ /dev/null @@ -1,192 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Task_Ex_T.h - * - * @author Kobi Cohen-Arazi - */ -//============================================================================= - -#ifndef ACE_TASK_EX_T_H -#define ACE_TASK_EX_T_H -#include /**/ "ace/pre.h" - -#include "ace/Service_Object.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Synch_Traits.h" -#include "ace/Task.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward decls... -template class ACE_Module; - -/** - * @class ACE_Task_Ex - * - * @brief Primary interface for application message processing, as well - * as input and output message queueing. - * - * Unlike ACE_Task, these class doesn't have the ability to be a part of - * a Stream chain. I.e. You cannot (yet) chain modules based on ACE_Task_Ex. - * - * @todo: We can merge ACE_Task and ACE_Task_Ex to be one class. - * something like that: - * template - * class ACE_Task : public ACE_Task_Base - * { - * // use here the code from ACE_Task_Ex using ACE_Message_Queue_Ex - * }; - * - * Now specialized version of ACE_Task with ACE_Message_Block as its - * ACE_MESSAGE_TYPE... - * - * template - * class ACE_Task : public ACE_Task_Base - * { - * // put here the good old ACE_Task code - * }; - * - * When User (and legacy code) write ACE_Task, specialized ACE_Task - * code is in action. - */ -template -class ACE_Task_Ex : public ACE_Task_Base, - private ACE_Copy_Disabled -{ -public: - friend class ACE_Module; - friend class ACE_Module_Type; - typedef ACE_Message_Queue_Ex MESSAGE_QUEUE_EX; - - // = Initialization/termination methods. - /** - * Initialize a Task, supplying a thread manager and a message - * queue. If the user doesn't supply a ACE_Message_Queue pointer - * then we'll allocate one dynamically. Otherwise, we'll use the - * one passed as a parameter. - */ - ACE_Task_Ex (ACE_Thread_Manager *thr_mgr = 0, - MESSAGE_QUEUE_EX *mq = 0); - - /// Destructor. - virtual ~ACE_Task_Ex (void); - - /// Gets the message queue associated with this task. - MESSAGE_QUEUE_EX *msg_queue (void); - - /// Sets the message queue associated with this task. - void msg_queue (MESSAGE_QUEUE_EX *); - -public: // Should be protected: - // = Message queue manipulation methods. - - // = Enqueue and dequeue methods. - - // For the following five method if @a timeout == 0, the caller will - // block until action is possible, else will wait until the - // <{absolute}> time specified in *@a timeout elapses). These calls - // will return, however, when queue is closed, deactivated, when a - // signal occurs, or if the time specified in timeout elapses, (in - // which case errno = EWOULDBLOCK). - - /// Insert message into the message queue. Note that @a timeout uses - /// <{absolute}> time rather than <{relative}> time. - int putq (ACE_MESSAGE_TYPE *, ACE_Time_Value *timeout = 0); - - /** - * Extract the first message from the queue (blocking). Note that - * @a timeout uses <{absolute}> time rather than <{relative}> time. - * Returns number of items in queue if the call succeeds or -1 otherwise. - */ - int getq (ACE_MESSAGE_TYPE *&mb, ACE_Time_Value *timeout = 0); - - /// Return a message to the queue. Note that @a timeout uses - /// <{absolute}> time rather than <{relative}> time. - int ungetq (ACE_MESSAGE_TYPE *, ACE_Time_Value *timeout = 0); - - /** - * Turn the message around and send it back down the Stream. Note - * that @a timeout uses <{absolute}> time rather than <{relative}> - * time. - */ - int reply (ACE_MESSAGE_TYPE *, ACE_Time_Value *timeout = 0); - - /** - * Transfer message to the adjacent ACE_Task_Ex in a ACE_Stream. Note - * that @a timeout uses <{absolute}> time rather than <{relative}> - * time. - */ - int put_next (ACE_MESSAGE_TYPE *msg, ACE_Time_Value *timeout = 0); - - // = ACE_Task utility routines to identify names et al. - /// Return the name of the enclosing Module if there's one associated - /// with the Task, else returns 0. - const ACE_TCHAR *name (void) const; - - // = Pointers to next ACE_Task_Base (if ACE is part of an ACE_Stream). - /// Get next Task pointer. - ACE_Task *next (void); - - /// Set next Task pointer. - void next (ACE_Task *); - - /// Alwasy return 0. @todo FIXME - ACE_Task *sibling (void); - - /// Return the Task's Module if there is one, else returns 0. - ACE_Module *module (void) const; - - /** - * Flush the task's queue, i.e., free all of the enqueued - * message blocks and releases any threads blocked on the queue. - * Note that if this conflicts with the C++ iostream - * function, just rewrite the iostream function as ::. - */ - int flush (u_long flag = ACE_Task_Flags::ACE_FLUSHALL); - - // = Special routines corresponding to certain message types. - - /// Manipulate watermarks. - void water_marks (ACE_IO_Cntl_Msg::ACE_IO_Cntl_Cmds, size_t); - - /// Queue of messages on the ACE_Task.. - MESSAGE_QUEUE_EX *msg_queue_; - - /// true if should delete Message_Queue, false otherwise. - bool delete_msg_queue_; - - /// Back-pointer to the enclosing module. - ACE_Module *mod_; - - /// Pointer to adjacent ACE_Task. - ACE_Task *next_; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Task_Ex_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Task_Ex_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Task_Ex_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_TASK_EX_H */ diff --git a/deps/acelite/ace/Task_Ex_T.inl b/deps/acelite/ace/Task_Ex_T.inl deleted file mode 100644 index a51323056..000000000 --- a/deps/acelite/ace/Task_Ex_T.inl +++ /dev/null @@ -1,99 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE void -ACE_Task_Ex::water_marks (ACE_IO_Cntl_Msg::ACE_IO_Cntl_Cmds cmd, - size_t wm_size) -{ - ACE_TRACE ("ACE_Task_Ex::water_marks"); - if (cmd == ACE_IO_Cntl_Msg::SET_LWM) - this->msg_queue_->low_water_mark (wm_size); - else /* cmd == ACE_IO_Cntl_Msg::SET_HWM */ - this->msg_queue_->high_water_mark (wm_size); -} - -template ACE_INLINE int -ACE_Task_Ex::getq (ACE_MESSAGE_TYPE *&mb, ACE_Time_Value *tv) -{ - ACE_TRACE ("ACE_Task_Ex::getq"); - return this->msg_queue_->dequeue_head (mb, tv); -} - -template ACE_INLINE int -ACE_Task_Ex::putq (ACE_MESSAGE_TYPE *mb, ACE_Time_Value *tv) -{ - ACE_TRACE ("ACE_Task_Ex::putq"); - return this->msg_queue_->enqueue_tail (mb, tv); -} - -template ACE_INLINE int -ACE_Task_Ex::ungetq (ACE_MESSAGE_TYPE *mb, ACE_Time_Value *tv) -{ - ACE_TRACE ("ACE_Task_Ex::ungetq"); - return this->msg_queue_->enqueue_head (mb, tv); -} - -template ACE_INLINE int -ACE_Task_Ex::flush (u_long flag) -{ - ACE_TRACE ("ACE_Task_Ex::flush"); - if (ACE_BIT_ENABLED (flag, ACE_Task_Flags::ACE_FLUSHALL)) - return this->msg_queue_ != 0 && this->msg_queue_->close (); - else - return -1; // Note, need to be more careful about what we free... -} - -template ACE_INLINE void -ACE_Task_Ex::msg_queue (ACE_Message_Queue_Ex *mq) -{ - ACE_TRACE ("ACE_Task_Ex::msg_queue"); - if (this->delete_msg_queue_) - { - delete this->msg_queue_; - this->delete_msg_queue_ = false; - } - this->msg_queue_ = mq; -} - -template ACE_Message_Queue_Ex * -ACE_Task_Ex::msg_queue (void) -{ - ACE_TRACE ("ACE_Task_Ex::msg_queue"); - return this->msg_queue_; -} - -template ACE_INLINE int -ACE_Task_Ex::reply (ACE_MESSAGE_TYPE *mb, ACE_Time_Value *tv) -{ - ACE_TRACE ("ACE_Task_Ex::reply"); - ACE_UNUSED_ARG (mb); - ACE_UNUSED_ARG (tv); - return -1 ; // this->sibling ()->put_next (mb, tv); -} - -template ACE_INLINE ACE_Task * -ACE_Task_Ex::next (void) -{ - ACE_TRACE ("ACE_Task_Ex::next"); - return this->next_; -} - -template ACE_INLINE void -ACE_Task_Ex::next (ACE_Task *q) -{ - ACE_TRACE ("ACE_Task_Ex::next"); - this->next_ = q; -} - -// Transfer msg to the next ACE_Task_Ex. - -template ACE_INLINE int -ACE_Task_Ex::put_next ( - ACE_MESSAGE_TYPE * /* msg */, - ACE_Time_Value * /* tv */) -{ - ACE_TRACE ("ACE_Task_Ex::put_next"); - return -1; // this->next_ == 0 ? -1 : this->next_->put (msg, tv); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Task_T.cpp b/deps/acelite/ace/Task_T.cpp deleted file mode 100644 index b28dd2cce..000000000 --- a/deps/acelite/ace/Task_T.cpp +++ /dev/null @@ -1,109 +0,0 @@ -#ifndef ACE_TASK_T_CPP -#define ACE_TASK_T_CPP - -#include "ace/Task_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Module.h" -#include "ace/Null_Condition.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Task_T.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE_Tyc(ACE_Task) - -template void -ACE_Task::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Task::dump"); - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nthr_mgr_ = %x"), this->thr_mgr_)); - this->msg_queue_->dump (); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("delete_msg_queue_ = %d\n"), this->delete_msg_queue_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nflags = %x"), this->flags_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nmod_ = %x"), this->mod_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nnext_ = %x"), this->next_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\ngrp_id_ = %d"), this->grp_id_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nthr_count_ = %d"), this->thr_count_)); -#if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) - this->lock_.dump (); -#endif /* ACE_MT_SAFE */ - - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -// If the user doesn't supply a ACE_Message_Queue pointer then we'll -// allocate one dynamically. Otherwise, we'll use the one they give. - -template -ACE_Task::ACE_Task (ACE_Thread_Manager *thr_man, - ACE_Message_Queue *mq) - : ACE_Task_Base (thr_man), - msg_queue_ (0), - delete_msg_queue_ (false), - mod_ (0), - next_ (0) -{ - ACE_TRACE ("ACE_Task::ACE_Task"); - - if (mq == 0) - { - typedef ACE_Message_Queue QUEUE_TYPE; - ACE_NEW (mq, - QUEUE_TYPE); - this->delete_msg_queue_ = true; - } - - this->msg_queue_ = mq; -} - -template -ACE_Task::~ACE_Task (void) -{ - ACE_TRACE ("ACE_Task::~ACE_Task"); - if (this->delete_msg_queue_) - delete this->msg_queue_; - - // These assignments aren't strickly necessary but they help guard - // against odd race conditions... - this->delete_msg_queue_ = false; -} - -template ACE_Task * -ACE_Task::sibling (void) -{ - ACE_TRACE ("ACE_Task::sibling"); - if (this->mod_ == 0) - return 0; - else - return this->mod_->sibling (this); -} - -template const ACE_TCHAR * -ACE_Task::name (void) const -{ - ACE_TRACE ("ACE_Task::name"); - if (this->mod_ == 0) - return 0; - else - return this->mod_->name (); -} - -template ACE_Module * -ACE_Task::module (void) const -{ - ACE_TRACE ("ACE_Task::module"); - return this->mod_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_TASK_T_CPP */ diff --git a/deps/acelite/ace/Task_T.h b/deps/acelite/ace/Task_T.h deleted file mode 100644 index 696117558..000000000 --- a/deps/acelite/ace/Task_T.h +++ /dev/null @@ -1,197 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Task_T.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_TASK_T_H -#define ACE_TASK_T_H -#include /**/ "ace/pre.h" - -#include "ace/Message_Queue.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Synch_Traits.h" -#include "ace/Task.h" -#include "ace/IO_Cntl_Msg.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward decls... -template class ACE_Module; - -/** - * @class ACE_Task - * - * @brief Primary interface for application message processing, as well - * as input and output message queueing. - * - * This class serves as the basis for passive and active objects - * in ACE. - */ -template -class ACE_Task : public ACE_Task_Base -{ -public: - friend class ACE_Module; - friend class ACE_Module_Type; - - // = Initialization/termination methods. - /** - * Initialize a Task, supplying a thread manager and a message - * queue. If the user doesn't supply a ACE_Message_Queue pointer - * then we'll allocate one dynamically. Otherwise, we'll use the - * one passed as a parameter. - */ - ACE_Task (ACE_Thread_Manager *thr_mgr = 0, - ACE_Message_Queue *mq = 0); - - /// Destructor. - virtual ~ACE_Task (void); - - /// Gets the message queue associated with this task. - ACE_Message_Queue *msg_queue (void); - - /// Sets the message queue associated with this task. - void msg_queue (ACE_Message_Queue *); - - /// Get the current time of day according to the queue's TIME_POLICY. - /// Allows users to initialize timeout values using correct time policy. - ACE_Time_Value_T gettimeofday (void) const; - - /// Allows applications to control how the timer queue gets the time - /// of day. - void set_time_policy (TIME_POLICY const & time_policy); - -public: // Should be protected: - // = Message queue manipulation methods. - - // = Enqueue and dequeue methods. - - // For the following five method if @a timeout == 0, the caller will - // block until action is possible, else will wait until the - // <{absolute}> time specified in *@a timeout elapses). These calls - // will return, however, when queue is closed, deactivated, when a - // signal occurs, or if the time specified in timeout elapses, (in - // which case errno = EWOULDBLOCK). - - /// Insert message into the message queue. Note that @a timeout uses - /// <{absolute}> time rather than <{relative}> time. - int putq (ACE_Message_Block *, ACE_Time_Value *timeout = 0); - - /** - * Extract the first message from the queue (blocking). Note that - * @a timeout uses <{absolute}> time rather than <{relative}> time. - * Returns number of items in queue if the call succeeds or -1 otherwise. - */ - int getq (ACE_Message_Block *&mb, ACE_Time_Value *timeout = 0); - - /// Return a message to the queue. Note that @a timeout uses - /// <{absolute}> time rather than <{relative}> time. - int ungetq (ACE_Message_Block *, ACE_Time_Value *timeout = 0); - - /** - * Turn the message around, sending it in the opposite direction in - * the stream. To do this, the message is put onto the task next in - * the stream after this task's sibling. - * - * @param mb Pointer to the block that is used in the reply. - * @param tv The absolute time at which the put operation used to - * send the message block to the next module in the stream - * will time out. If 0, this call blocks until it can be - * completed. - */ - int reply (ACE_Message_Block *mb, ACE_Time_Value *tv = 0); - - /** - * Transfer message to the adjacent ACE_Task in a ACE_Stream. Note - * that @a timeout uses <{absolute}> time rather than <{relative}> - * time. - */ - int put_next (ACE_Message_Block *msg, ACE_Time_Value *timeout = 0); - - // = ACE_Task utility routines to identify names et al. - /// Return the name of the enclosing Module if there's one associated - /// with the Task, else returns 0. - const ACE_TCHAR *name (void) const; - - // = Pointers to next ACE_Task_Base (if ACE is part of an ACE_Stream). - /// Get next Task pointer. - ACE_Task *next (void); - - /// Set next Task pointer. - void next (ACE_Task *); - - /// Return the Task's sibling if there's one associated with the - /// Task's Module, else returns 0. - ACE_Task *sibling (void); - - /// Return the Task's Module if there is one, else returns 0. - ACE_Module *module (void) const; - - /** - * Flush the task's queue, i.e., free all of the enqueued - * message blocks and unblocks any threads waiting on the queue. - * Note that if this conflicts with the C++ iostream - * function, just rewrite the iostream function as ::. - */ - int flush (u_long flag = ACE_Task_Flags::ACE_FLUSHALL); - - // = Special routines corresponding to certain message types. - - /// Manipulate watermarks. - void water_marks (ACE_IO_Cntl_Msg::ACE_IO_Cntl_Cmds, size_t); - - /// Queue of messages on the ACE_Task.. - ACE_Message_Queue *msg_queue_; - - /// true if should delete Message_Queue, false otherwise. - bool delete_msg_queue_; - - /// Back-pointer to the enclosing module. - ACE_Module *mod_; - - /// Pointer to adjacent ACE_Task. - ACE_Task *next_; - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - - // = Disallow these operations. - ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Task &)) - ACE_UNIMPLEMENTED_FUNC (ACE_Task (const ACE_Task &)) -}; - -#if defined ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION_EXPORT -template class ACE_Export ACE_Task; -template class ACE_Export ACE_Task; -#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION_EXPORT */ - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Task_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Task_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Task_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_TASK_T_H */ diff --git a/deps/acelite/ace/Task_T.inl b/deps/acelite/ace/Task_T.inl deleted file mode 100644 index 99de01add..000000000 --- a/deps/acelite/ace/Task_T.inl +++ /dev/null @@ -1,113 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template ACE_INLINE void -ACE_Task::water_marks (ACE_IO_Cntl_Msg::ACE_IO_Cntl_Cmds cmd, - size_t wm_size) -{ - ACE_TRACE ("ACE_Task::water_marks"); - if (cmd == ACE_IO_Cntl_Msg::SET_LWM) - this->msg_queue_->low_water_mark (wm_size); - else /* cmd == ACE_IO_Cntl_Msg::SET_HWM */ - this->msg_queue_->high_water_mark (wm_size); -} - -template ACE_INLINE int -ACE_Task::getq (ACE_Message_Block *&mb, ACE_Time_Value *tv) -{ - ACE_TRACE ("ACE_Task::getq"); - return this->msg_queue_->dequeue_head (mb, tv); -} - -template ACE_INLINE int -ACE_Task::putq (ACE_Message_Block *mb, ACE_Time_Value *tv) -{ - ACE_TRACE ("ACE_Task::putq"); - return this->msg_queue_->enqueue_tail (mb, tv); -} - -template ACE_INLINE int -ACE_Task::ungetq (ACE_Message_Block *mb, ACE_Time_Value *tv) -{ - ACE_TRACE ("ACE_Task::ungetq"); - return this->msg_queue_->enqueue_head (mb, tv); -} - -template ACE_INLINE int -ACE_Task::flush (u_long f) -{ - ACE_TRACE ("ACE_Task::flush"); - if (ACE_BIT_ENABLED (f, ACE_Task_Flags::ACE_FLUSHALL)) - return this->msg_queue_ != 0 && this->msg_queue_->close (); - else - return -1; // Note, need to be more careful about what we free... -} - -template ACE_INLINE void -ACE_Task::msg_queue (ACE_Message_Queue *mq) -{ - ACE_TRACE ("ACE_Task::msg_queue"); - if (this->delete_msg_queue_) - { - delete this->msg_queue_; - this->delete_msg_queue_ = false; - } - this->msg_queue_ = mq; -} - -template ACE_Message_Queue * -ACE_Task::msg_queue (void) -{ - ACE_TRACE ("ACE_Task::msg_queue"); - return this->msg_queue_; -} - -template -ACE_Time_Value_T -ACE_Task::gettimeofday (void) const -{ - if (this->msg_queue_ != 0) - return this->msg_queue_->gettimeofday (); - - return ACE_Time_Value_T (ACE_Time_Value::zero); -} - -template -void -ACE_Task::set_time_policy (TIME_POLICY const & rhs) -{ - if (this->msg_queue_ != 0) - this->msg_queue_->set_time_policy (rhs); -} - -template ACE_INLINE int -ACE_Task::reply (ACE_Message_Block *mb, ACE_Time_Value *tv) -{ - ACE_TRACE ("ACE_Task::reply"); - return this->sibling ()->put_next (mb, tv); -} - -template ACE_INLINE ACE_Task * -ACE_Task::next (void) -{ - ACE_TRACE ("ACE_Task::next"); - return this->next_; -} - -template ACE_INLINE void -ACE_Task::next (ACE_Task *q) -{ - ACE_TRACE ("ACE_Task::next"); - this->next_ = q; -} - -// Transfer msg to the next ACE_Task. - -template ACE_INLINE int -ACE_Task::put_next (ACE_Message_Block *msg, ACE_Time_Value *tv) -{ - ACE_TRACE ("ACE_Task::put_next"); - return this->next_ == 0 ? -1 : this->next_->put (msg, tv); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Test_and_Set.cpp b/deps/acelite/ace/Test_and_Set.cpp deleted file mode 100644 index 4ba0dd61d..000000000 --- a/deps/acelite/ace/Test_and_Set.cpp +++ /dev/null @@ -1,49 +0,0 @@ -#ifndef ACE_TEST_AND_SET_CPP -#define ACE_TEST_AND_SET_CPP - -#include "ace/Test_and_Set.h" -#include "ace/Guard_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Test_and_Set::ACE_Test_and_Set (TYPE initial_value) - : is_set_ (initial_value) -{ -} - -// Returns true if we are done, else false. -template TYPE -ACE_Test_and_Set::is_set (void) const -{ - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, (ACE_LOCK &) this->lock_, this->is_set_); - return this->is_set_; -} - -// Sets the status. -template TYPE -ACE_Test_and_Set::set (TYPE status) -{ - ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->lock_, this->is_set_); - TYPE o_status = this->is_set_; - this->is_set_ = status; - return o_status; -} - -template int -ACE_Test_and_Set::handle_signal (int, siginfo_t *, ucontext_t *) -{ - // By setting this to 1, we are "signaling" to anyone calling - // or or that the "test and set" object is in the - // "signaled" state, i.e., it's "available" to be set back to 0. - this->set (1); - return 0; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_TEST_AND_SET_CPP */ diff --git a/deps/acelite/ace/Test_and_Set.h b/deps/acelite/ace/Test_and_Set.h deleted file mode 100644 index 6ec541a69..000000000 --- a/deps/acelite/ace/Test_and_Set.h +++ /dev/null @@ -1,71 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Test_and_Set.h - */ -//============================================================================= - - -#ifndef ACE_TEST_AND_SET_H -#define ACE_TEST_AND_SET_H - -#include /**/ "ace/pre.h" -#include "ace/Event_Handler.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Test_and_Set - * - * @brief Implements the classic ``test and set'' operation. - * - * This class keeps track of the status of , which can be - * set based on various events (such as receipt of a signal). - * This class is derived from ACE_Event_Handler so that it can be - * "signaled" by a Reactor when a signal occurs. We assume that - * is a data type that can be assigned the value 0 or 1. - */ -template -class ACE_Test_and_Set : public ACE_Event_Handler -{ -public: - ACE_Test_and_Set (TYPE initial_value = 0); - - /// Returns true if we are set, else false. - TYPE is_set (void) const; - - /// Sets the status, returning the original value of - /// . - TYPE set (TYPE); - - /// Called when object is signaled by OS (either via UNIX signals or - /// when a Win32 object becomes signaled). - virtual int handle_signal (int signum, - siginfo_t * = 0, - ucontext_t * = 0); - -private: - /// Keeps track of our state. - TYPE is_set_; - - /// Protect the state from race conditions. - ACE_LOCK lock_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Test_and_Set.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Test_and_Set.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - -#include /**/ "ace/post.h" -#endif /* ACE_TEST_AND_SET_H */ diff --git a/deps/acelite/ace/Thread.cpp b/deps/acelite/ace/Thread.cpp deleted file mode 100644 index c8ff2e3bf..000000000 --- a/deps/acelite/ace/Thread.cpp +++ /dev/null @@ -1,95 +0,0 @@ -#include "ace/Thread.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Thread.inl" -#endif /* !defined (__ACE_INLINE__) */ - -#if defined (ACE_HAS_THREADS) - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -size_t -ACE_Thread::spawn_n (size_t n, - ACE_THR_FUNC func, - void *arg, - long flags, - long priority, - void *stack[], - size_t stack_size[], - ACE_Thread_Adapter *thread_adapter, - const char* thr_name[]) -{ - ACE_TRACE ("ACE_Thread::spawn_n"); - size_t i; - - for (i = 0; i < n; i++) - { - ACE_thread_t t_id; - // Bail out if error occurs. - if (ACE_OS::thr_create (func, - arg, - flags, - &t_id, - 0, - priority, - stack == 0 ? 0 : stack[i], - stack_size == 0 ? ACE_DEFAULT_THREAD_STACKSIZE : stack_size[i], - thread_adapter, - thr_name == 0 ? 0 : &thr_name[i]) != 0) - break; - } - - return i; -} - -size_t -ACE_Thread::spawn_n (ACE_thread_t thread_ids[], - size_t n, - ACE_THR_FUNC func, - void *arg, - long flags, - long priority, - void *stack[], - size_t stack_size[], - ACE_hthread_t thread_handles[], - ACE_Thread_Adapter *thread_adapter, - const char* thr_name[]) -{ - ACE_TRACE ("ACE_Thread::spawn_n"); - size_t i = 0; - - for (i = 0; i < n; i++) - { - ACE_thread_t t_id; - ACE_hthread_t t_handle; - - int const result = - ACE_OS::thr_create (func, - arg, - flags, - &t_id, - &t_handle, - priority, - stack == 0 ? 0 : stack[i], - stack_size == 0 ? ACE_DEFAULT_THREAD_STACKSIZE : stack_size[i], - thread_adapter, - thr_name == 0 ? 0 : &thr_name[i]); - - if (result == 0) - { - if (thread_ids != 0) - thread_ids[i] = t_id; - if (thread_handles != 0) - thread_handles[i] = t_handle; - } - else - // Bail out if error occurs. - break; - } - - return i; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_THREADS */ diff --git a/deps/acelite/ace/Thread.h b/deps/acelite/ace/Thread.h deleted file mode 100644 index 6290de52e..000000000 --- a/deps/acelite/ace/Thread.h +++ /dev/null @@ -1,280 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Thread.h - * - * @author Douglas Schmidt - */ -//========================================================================== - -#ifndef ACE_THREAD_H -#define ACE_THREAD_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/OS_NS_Thread.h" -#include "ace/Thread_Adapter.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -struct cancel_state -{ - /// e.g., PTHREAD_CANCEL_ENABLE, PTHREAD_CANCEL_DISABLE, - /// PTHREAD_CANCELED. - int cancelstate; - - /// e.g., PTHREAD_CANCEL_DEFERRED and PTHREAD_CANCEL_ASYNCHRONOUS. - int canceltype; -}; - -/** - * @class ACE_Thread - * - * @brief Provides a wrapper for threads. - * - * This class provides a common interface that is mapped onto - * POSIX Pthreads, Solaris threads, Win32 threads, VxWorks - * threads, or pSoS threads. Note, however, that it is - * generally a better idea to use the ACE_Thread_Manager - * programming API rather than the API since the - * thread manager is more powerful. - */ -class ACE_Export ACE_Thread -{ -public: - /** - * Creates a new thread having @a flags attributes and running @a func - * with @a args (if @a thread_adapter is non-0 then @a func and @a args - * are ignored and are obtained from @a thread_adapter>. @a thr_id - * and @a t_handle are set to the thread's ID and handle (?), - * respectively. The thread runs at @a priority priority (see - * below). - * - * The @a flags are a bitwise-OR of the following: - * = BEGIN - * THR_CANCEL_DISABLE, THR_CANCEL_ENABLE, THR_CANCEL_DEFERRED, - * THR_CANCEL_ASYNCHRONOUS, THR_BOUND, THR_NEW_LWP, THR_DETACHED, - * THR_SUSPENDED, THR_DAEMON, THR_JOINABLE, THR_SCHED_FIFO, - * THR_SCHED_RR, THR_SCHED_DEFAULT, THR_EXPLICIT_SCHED, - * THR_SCOPE_SYSTEM, THR_SCOPE_PROCESS - * = END - * - * By default, or if @a priority is set to - * ACE_DEFAULT_THREAD_PRIORITY, an "appropriate" priority value for - * the given scheduling policy (specified in @a flags, e.g., - * @c THR_SCHED_DEFAULT is used. This value is calculated - * dynamically, and is the median value between the minimum and - * maximum priority values for the given policy. If an explicit - * value is given, it is used. Note that actual priority values are - * EXTREMELY implementation-dependent, and are probably best - * avoided. - * - * Note that @a thread_adapter is always deleted when @a spawn - * is called, so it must be allocated with global operator new. - */ - static int spawn (ACE_THR_FUNC func, - void *arg = 0, - long flags = THR_NEW_LWP | THR_JOINABLE, - ACE_thread_t *t_id = 0, - ACE_hthread_t *t_handle = 0, - long priority = ACE_DEFAULT_THREAD_PRIORITY, - void *stack = 0, - size_t stack_size = ACE_DEFAULT_THREAD_STACKSIZE, - ACE_Thread_Adapter *thread_adapter = 0, - const char** thr_name = 0); - - /** - * Spawn N new threads, which execute @a func with argument @a arg (if - * @a thread_adapter is non-0 then @a func and @a args are ignored and - * are obtained from @a thread_adapter). If @a stack != 0 it is - * assumed to be an array of @a n pointers to the base of the stacks - * to use for the threads being spawned. Likewise, if @a stack_size - * != 0 it is assumed to be an array of @a n values indicating how - * big each of the corresponding @a stacks are. Returns the number - * of threads actually spawned (if this doesn't equal the number - * requested then something has gone wrong and @c errno will - * explain...). - * - * @see spawn() - */ - static size_t spawn_n (size_t n, - ACE_THR_FUNC func, - void *arg = 0, - long flags = THR_NEW_LWP | THR_JOINABLE, - long priority = ACE_DEFAULT_THREAD_PRIORITY, - void *stack[] = 0, - size_t stack_size[] = 0, - ACE_Thread_Adapter *thread_adapter = 0, - const char* thr_name[] = 0); - - /** - * Spawn @a n new threads, which execute @a func with argument @a arg - * (if @a thread_adapter is non-0 then @a func and @a args are ignored - * and are obtained from @a thread_adapter). The thread_ids of - * successfully spawned threads will be placed into the @a thread_ids - * buffer (which must be the same size as @a n). If @a stack != 0 it - * is assumed to be an array of @a n pointers to the base of the - * stacks to use for the threads being spawned. If @a stack_size != - * 0 it is assumed to be an array of @a n values indicating how big - * each of the corresponding @a stacks are. If @a thread_handles != 0 - * it is assumed to be an array of @a n thread_handles that will be - * assigned the values of the thread handles being spawned. Returns - * the number of threads actually spawned (if this doesn't equal the - * number requested then something has gone wrong and @c errno will - * explain...). - * - * @see spawn() - */ - static size_t spawn_n (ACE_thread_t thread_ids[], - size_t n, - ACE_THR_FUNC func, - void *arg, - long flags, - long priority = ACE_DEFAULT_THREAD_PRIORITY, - void *stack[] = 0, - size_t stack_size[] = 0, - ACE_hthread_t thread_handles[] = 0, - ACE_Thread_Adapter *thread_adapter = 0, - const char* thr_name[] = 0); - - /** - * Wait for one or more threads to exit and reap their exit status. - * thr_join() returns successfully when the target thread terminates. - * - * @param thread_id is the ACE_thread_t ID of the thread to wait for. - * If @a thread_id is 0, join() waits for any - * undetached thread in the process to terminate - * on platforms that support this capability - * (for example, Solaris). - * @param departed points to a location that is set to the ID of the - * terminated thread if join() returns successfully. - * If @a departed is 0, it is ignored. - * @param status Points to the location that receives the joined - * thread's exit value. If @a status is 0, it is ignored. - * - * @retval 0 for success - * @retval -1 (with errno set) for failure. - */ - static int join (ACE_thread_t thread_id, - ACE_thread_t *departed, - ACE_THR_FUNC_RETURN *status); - - /// Wait for one thread to exit and reap its exit status. - static int join (ACE_hthread_t, - ACE_THR_FUNC_RETURN * = 0); - - /// Continue the execution of a previously suspended thread. - static int resume (ACE_hthread_t); - - /// Suspend the execution of a particular thread. - static int suspend (ACE_hthread_t); - - /// Get the priority of a particular thread. - static int getprio (ACE_hthread_t ht_id, int &priority); - - /// Get the priority and policy of a particular thread. - static int getprio (ACE_hthread_t ht_id, int &priority, int &policy); - - /// Set the priority of a particular thread. - static int setprio (ACE_hthread_t ht_id, int priority, int policy = -1); - - /// Send a signal to the thread. - static int kill (ACE_thread_t, int signum); - - /// Yield the thread to another. - static void yield (void); - - /** - * Return the unique kernel handle of the thread. Note that on - * Win32 this is actually a pseudohandle, which cannot be shared - * with other processes or waited on by threads. To locate the real - * handle, please use the ACE_Thread_Manager::thr_self() method. - */ - static void self (ACE_hthread_t &t_handle); - - /// Return the unique ID of the thread. - static ACE_thread_t self (void); - - /// Exit the current thread and return "status". - /// Should _not_ be called by main thread. - static void exit (ACE_THR_FUNC_RETURN status = 0); - - /// Get the LWP concurrency level of the process. - static int getconcurrency (void); - - /// Set the LWP concurrency level of the process. - static int setconcurrency (int new_level); - - /// Change and/or examine calling thread's signal mask. - static int sigsetmask (int how, - const sigset_t *sigset, - sigset_t *osigset = 0); - - /** - * Allocates a @a keyp that is used to identify data that is specific - * to each thread in the process. The key is global to all threads - * in the process. - */ - static int keycreate (ACE_thread_key_t *keyp, -#if defined (ACE_HAS_THR_C_DEST) - ACE_THR_C_DEST destructor -#else - ACE_THR_DEST destructor -#endif /* ACE_HAS_THR_C_DEST */ - ); - - /// Free up the key so that other threads can reuse it. - static int keyfree (ACE_thread_key_t key); - - /// Bind value to the thread-specific data key, @a key, for the calling - /// thread. - static int setspecific (ACE_thread_key_t key, - void *value); - - /// Stores the current value bound to @a key for the calling thread - /// into the location pointed to by @a valuep. - static int getspecific (ACE_thread_key_t key, - void **valuep); - - /// Disable thread cancellation. - static int disablecancel (struct cancel_state *old_state); - - /// Enable thread cancellation. - static int enablecancel (struct cancel_state *old_state, - int flag); - - /// Set the cancellation state. - static int setcancelstate (struct cancel_state &new_state, - struct cancel_state *old_state); - - /** - * Cancel a thread. - * @note This method is only portable on platforms, such as POSIX pthreads, - * that support thread cancellation. - */ - static int cancel (ACE_thread_t t_id); - - /// Test the cancel. - static void testcancel (void); - -private: - /// Ensure that we don't get instantiated. - ACE_Thread (void); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Thread.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" - -#endif /* ACE_THREAD_H */ diff --git a/deps/acelite/ace/Thread.inl b/deps/acelite/ace/Thread.inl deleted file mode 100644 index 33f7fcf0b..000000000 --- a/deps/acelite/ace/Thread.inl +++ /dev/null @@ -1,283 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_string.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Allocates a that is used to identify data that is specific -// to each thread in the process. The key is global to all threads in -// the process. - -ACE_INLINE int -ACE_Thread::keycreate (ACE_thread_key_t *keyp, -#if defined (ACE_HAS_THR_C_DEST) - ACE_THR_C_DEST destructor -#else - ACE_THR_DEST destructor -#endif /* ACE_HAS_THR_C_DEST */ - ) -{ - // ACE_TRACE ("ACE_Thread::keycreate"); - return ACE_OS::thr_keycreate (keyp, destructor); -} - -// Free up the key so that other threads can reuse it. - -ACE_INLINE int -ACE_Thread::keyfree (ACE_thread_key_t key) -{ - ACE_TRACE ("ACE_Thread::keyfree"); - return ACE_OS::thr_keyfree (key); -} - -// Bind value to the thread-specific data key, , for the calling -// thread. - -ACE_INLINE int -ACE_Thread::setspecific (ACE_thread_key_t key, void *value) -{ - // ACE_TRACE ("ACE_Thread::setspecific"); - return ACE_OS::thr_setspecific (key, value); -} - -// Stores the current value bound to for the calling thread -// into the location pointed to by . - -ACE_INLINE int -ACE_Thread::getspecific (ACE_thread_key_t key, void **valuep) -{ - // ACE_TRACE ("ACE_Thread::getspecific"); - return ACE_OS::thr_getspecific (key, valuep); -} - -ACE_INLINE ACE_thread_t -ACE_Thread::self (void) -{ -// ACE_TRACE ("ACE_Thread::self"); - return ACE_OS::thr_self (); -} - -ACE_INLINE void -ACE_Thread::exit (ACE_THR_FUNC_RETURN status) -{ - ACE_TRACE ("ACE_Thread::exit"); - ACE_OS::thr_exit (status); -} - -ACE_INLINE void -ACE_Thread::yield (void) -{ - ACE_TRACE ("ACE_Thread::yield"); - ACE_OS::thr_yield (); -} - -ACE_INLINE int -ACE_Thread::spawn (ACE_THR_FUNC func, - void *arg, - long flags, - ACE_thread_t *t_id, - ACE_hthread_t *t_handle, - long priority, - void *thr_stack, - size_t thr_stack_size, - ACE_Thread_Adapter *thread_adapter, - const char** thr_name) -{ - ACE_TRACE ("ACE_Thread::spawn"); - - return ACE_OS::thr_create (func, - arg, - flags, - t_id, - t_handle, - priority, - thr_stack, - thr_stack_size, - thread_adapter, - thr_name); -} - -ACE_INLINE int -ACE_Thread::resume (ACE_hthread_t t_id) -{ - ACE_TRACE ("ACE_Thread::resume"); - return ACE_OS::thr_continue (t_id); -} - -ACE_INLINE int -ACE_Thread::suspend (ACE_hthread_t t_id) -{ - ACE_TRACE ("ACE_Thread::suspend"); - return ACE_OS::thr_suspend (t_id); -} - -ACE_INLINE int -ACE_Thread::kill (ACE_thread_t t_id, int signum) -{ - ACE_TRACE ("ACE_Thread::kill"); - return ACE_OS::thr_kill (t_id, signum); -} - -ACE_INLINE int -ACE_Thread::join (ACE_thread_t wait_for, - ACE_thread_t *departed, - ACE_THR_FUNC_RETURN *status) -{ - ACE_TRACE ("ACE_Thread::join"); - return ACE_OS::thr_join (wait_for, departed, status); -} - -ACE_INLINE int -ACE_Thread::join (ACE_hthread_t wait_for, - ACE_THR_FUNC_RETURN *status) -{ - ACE_TRACE ("ACE_Thread::join"); - return ACE_OS::thr_join (wait_for, status); -} - -ACE_INLINE int -ACE_Thread::getconcurrency (void) -{ - ACE_TRACE ("ACE_Thread::getconcurrency"); - return ACE_OS::thr_getconcurrency (); -} - -ACE_INLINE int -ACE_Thread::setconcurrency (int new_level) -{ - ACE_TRACE ("ACE_Thread::setconcurrency"); - return ACE_OS::thr_setconcurrency (new_level); -} - -ACE_INLINE int -ACE_Thread::sigsetmask (int how, - const sigset_t *sigset, - sigset_t *osigset) -{ - ACE_TRACE ("ACE_Thread::sigsetmask"); - return ACE_OS::thr_sigsetmask (how, sigset, osigset); -} - -ACE_INLINE int -ACE_Thread::disablecancel (struct cancel_state *old_state) -{ - ACE_TRACE ("ACE_Thread::disablecancel"); - int old_cstate = 0; - int result = ACE_OS::thr_setcancelstate (THR_CANCEL_DISABLE, - &old_cstate); - if (result == 0 && old_state != 0) - { - ACE_OS::memset (old_state, - 0, - sizeof (*old_state)); - old_state->cancelstate = old_cstate; - } - - return result; -} - -ACE_INLINE int -ACE_Thread::enablecancel (struct cancel_state *old_state, - int flag) -{ - ACE_TRACE ("ACE_Thread::enablecancel"); - int old_cstate = 0; - int old_ctype = 0; - int result; - - result = ACE_OS::thr_setcancelstate (THR_CANCEL_ENABLE, - &old_cstate); - if (result != 0) - return result; - - result = ACE_OS::thr_setcanceltype (flag, - &old_ctype); - if (result != 0) - return result; - - if (old_state != 0) - { - old_state->cancelstate = old_cstate; - old_state->canceltype = old_ctype; - } - - return 0; -} - -ACE_INLINE int -ACE_Thread::setcancelstate (struct cancel_state &new_state, - struct cancel_state *old_state) -{ - ACE_TRACE ("ACE_Thread::setcancelstate"); - int old_cstate = 0; - int old_ctype = 0; - - if (new_state.cancelstate != 0 - && ACE_OS::thr_setcancelstate (new_state.cancelstate, - &old_cstate) != 0) - return -1; - - if (new_state.canceltype != 0 - && ACE_OS::thr_setcanceltype (new_state.canceltype, - &old_ctype) != 0) - { - int o_cstate; - - ACE_OS::thr_setcancelstate (old_cstate, - &o_cstate); - return -1; - } - - if (old_state != 0) - { - old_state->cancelstate = old_cstate; - old_state->canceltype = old_ctype; - } - - return 0; -} - -ACE_INLINE int -ACE_Thread::cancel (ACE_thread_t t_id) -{ - ACE_TRACE ("ACE_Thread::cancel"); - - return ACE_OS::thr_cancel (t_id); -} - -ACE_INLINE void -ACE_Thread::testcancel (void) -{ - ACE_TRACE ("ACE_Thread::testcancel"); - - ACE_OS::thr_testcancel (); -} - -ACE_INLINE void -ACE_Thread::self (ACE_hthread_t &t_id) -{ -// ACE_TRACE ("ACE_Thread::self"); - ACE_OS::thr_self (t_id); -} - -ACE_INLINE int -ACE_Thread::getprio (ACE_hthread_t ht_id, int &priority) -{ - ACE_TRACE ("ACE_Thread::getprio"); - return ACE_OS::thr_getprio (ht_id, priority); -} - -ACE_INLINE int -ACE_Thread::getprio (ACE_hthread_t ht_id, int &priority, int &policy) -{ - ACE_TRACE ("ACE_Thread::getprio"); - return ACE_OS::thr_getprio (ht_id, priority, policy); -} - -ACE_INLINE int -ACE_Thread::setprio (ACE_hthread_t ht_id, int priority, int policy) -{ - ACE_TRACE ("ACE_Thread::setprio"); - return ACE_OS::thr_setprio (ht_id, priority, policy); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Thread_Adapter.cpp b/deps/acelite/ace/Thread_Adapter.cpp deleted file mode 100644 index 905eefddc..000000000 --- a/deps/acelite/ace/Thread_Adapter.cpp +++ /dev/null @@ -1,240 +0,0 @@ -#include "ace/Thread_Adapter.h" -#include "ace/Thread_Manager.h" -#include "ace/Thread_Exit.h" -#include "ace/Thread_Hook.h" -#include "ace/Object_Manager_Base.h" -#include "ace/Service_Config.h" - -#if !defined (ACE_HAS_INLINED_OSCALLS) -# include "ace/Thread_Adapter.inl" -#endif /* ACE_HAS_INLINED_OSCALLS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Thread_Adapter::ACE_Thread_Adapter (ACE_THR_FUNC user_func, - void *arg, - ACE_THR_C_FUNC entry_point, - ACE_Thread_Manager *tm, - ACE_Thread_Descriptor *td -#if defined (ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS) - , ACE_SEH_EXCEPT_HANDLER selector, - ACE_SEH_EXCEPT_HANDLER handler -#endif /* ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS */ - , long cancel_flags - ) - : ACE_Base_Thread_Adapter ( - user_func - , arg - , entry_point - , td -#if defined (ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS) - , selector - , handler -#endif /* ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS */ - , cancel_flags - ) - , thr_mgr_ (tm) -{ - ACE_OS_TRACE ("ACE_Thread_Adapter::ACE_Thread_Adapter"); -} - -ACE_Thread_Adapter::~ACE_Thread_Adapter (void) -{ -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Adapter); - -ACE_THR_FUNC_RETURN -ACE_Thread_Adapter::invoke (void) -{ - // Inherit the logging features if the parent thread has an - // ACE_Log_Msg instance in thread-specific storage. - this->inherit_log_msg (); - - ACE_Service_Config::current (ACE_Service_Config::global()); - -#if !defined(ACE_USE_THREAD_MANAGER_ADAPTER) - // NOTE: this preprocessor directive should match the one in above - // ACE_Thread_Exit::instance (). With the Xavier Pthreads package, - // the exit_hook in TSS causes a seg fault. So, this works around - // that by creating exit_hook on the stack. -# if defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION) - // Obtain our thread-specific exit hook and make sure that it knows - // how to clean us up! Note that we never use this pointer directly - // (it's stored in thread-specific storage), so it's ok to - // dereference it here and only store it as a reference. - - // Except if it is null, then the thr_mgr() method crashes. - // -jxh - - ACE_Thread_Exit *exit_hook_instance = ACE_Thread_Exit::instance (); - ACE_Thread_Exit_Maybe exit_hook_maybe (exit_hook_instance == 0); - ACE_Thread_Exit *exit_hook_ptr = exit_hook_instance - ? exit_hook_instance - : exit_hook_maybe.instance (); - ACE_Thread_Exit &exit_hook = *exit_hook_ptr; - - if (this->thr_mgr () != 0) - { - // Keep track of the that's associated with this - // . - exit_hook.thr_mgr (this->thr_mgr ()); - } -# else - // Without TSS, create an instance. When this - // function returns, its destructor will be called because the - // object goes out of scope. The drawback with this appraoch is - // that the destructor _won't_ get called if is called. - // So, threads shouldn't exit that way. Instead, they should return - // from . - ACE_Thread_Exit exit_hook; - exit_hook.thr_mgr (this->thr_mgr ()); -# endif /* ACE_HAS_THREAD_SPECIFIC_STORAGE || ACE_HAS_TSS_EMULATION */ - -#endif /* ! ACE_USE_THREAD_MANAGER_ADAPTER */ - - return this->invoke_i (); -} - -ACE_THR_FUNC_RETURN -ACE_Thread_Adapter::invoke_i (void) -{ - // Extract the arguments. - ACE_THR_FUNC func = reinterpret_cast (this->user_func_); - void *arg = this->arg_; - -#if defined (ACE_WIN32) && defined (ACE_HAS_MFC) && (ACE_HAS_MFC != 0) - ACE_OS_Thread_Descriptor *thr_desc = this->thr_desc_; -#endif /* ACE_WIN32 && ACE_HAS_MFC && (ACE_HAS_MFC != 0) */ - - // Pick up the cancel-related flags before deleting this. - long cancel_flags = this->flags_; - - // Delete ourselves since we don't need anymore. Make sure - // not to access anywhere below this point. - delete this; - -#if defined (ACE_NEEDS_LWP_PRIO_SET) - // On SunOS, the LWP priority needs to be set in order to get - // preemption when running in the RT class. This is the ACE way to - // do that . . . - ACE_hthread_t thr_handle; - ACE_OS::thr_self (thr_handle); - int prio; - - // thr_getprio () on the current thread should never fail. - ACE_OS::thr_getprio (thr_handle, prio); - - // ACE_OS::thr_setprio () has the special logic to set the LWP priority, - // if running in the RT class. - ACE_OS::thr_setprio (prio); - -#endif /* ACE_NEEDS_LWP_PRIO_SET */ - if (cancel_flags != 0) - { - // If both flags are set, ignore this. - int old = 0; - int val = cancel_flags & (THR_CANCEL_ENABLE | THR_CANCEL_DISABLE); - if (val == THR_CANCEL_ENABLE || val == THR_CANCEL_DISABLE) - ACE_OS::thr_setcancelstate (val, &old); - val = cancel_flags & (THR_CANCEL_DEFERRED | THR_CANCEL_ASYNCHRONOUS); - if (val == THR_CANCEL_DEFERRED || val == THR_CANCEL_ASYNCHRONOUS) - ACE_OS::thr_setcanceltype (val, &old); - } - - ACE_THR_FUNC_RETURN status = 0; - - ACE_SEH_TRY - { - ACE_SEH_TRY - { - ACE_Thread_Hook *hook = - ACE_OS_Object_Manager::thread_hook (); - - if (hook) - // Invoke the start hook to give the user a chance to - // perform some initialization processing before the - // is invoked. - status = hook->start (func, arg); - else - // Call thread entry point. - status = (*func) (arg); - } - -#if defined (ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS) - ACE_SEH_EXCEPT (ACE_OS_Object_Manager::seh_except_selector ()( - (void *) GetExceptionInformation ())) - { - ACE_OS_Object_Manager::seh_except_handler ()(0); - } -#endif /* ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS */ - } - - ACE_SEH_FINALLY - { - // If we changed this to 1, change the respective if in - // Task::svc_run to 0. -#if 0 - // Call the close> hook. - if (func == reinterpret_cast ( - ACE_Task_Base::svc_run)) - { - ACE_Task_Base *task_ptr = (ACE_Task_Base *) arg; - ACE_Thread_Manager *thr_mgr_ptr = task_ptr->thr_mgr (); - - // This calls the Task->close () hook. - task_ptr->cleanup (task_ptr, 0); - - // This prevents a second invocation of the cleanup code - // (called later by . - thr_mgr_ptr->at_exit (task_ptr, 0, 0); - } -#endif /* 0 */ - -#if defined (ACE_WIN32) || defined (ACE_HAS_TSS_EMULATION) -# if defined (ACE_WIN32) && defined (ACE_HAS_MFC) && (ACE_HAS_MFC != 0) - int using_afx = -1; - if (thr_desc) - using_afx = ACE_BIT_ENABLED (thr_desc->flags (), THR_USE_AFX); -# endif /* ACE_WIN32 && ACE_HAS_MFC && (ACE_HAS_MFC != 0) */ - // Call TSS destructors. - ACE_OS::cleanup_tss (0 /* not main thread */); - -# if defined (ACE_WIN32) - // Exit the thread. Allow CWinThread-destructor to be invoked - // from AfxEndThread. _endthreadex will be called from - // AfxEndThread so don't exit the thread now if we are running - // an MFC thread. -# if defined (ACE_HAS_MFC) && (ACE_HAS_MFC != 0) - if (using_afx != -1) - { - if (using_afx) - ::AfxEndThread ((DWORD) status); - else - ACE_ENDTHREADEX (status); - } - else - { - // Not spawned by ACE_Thread_Manager, use the old buggy - // version. You should seriously consider using - // ACE_Thread_Manager to spawn threads. The following code - // is know to cause some problem. - CWinThread *pThread = ::AfxGetThread (); - - if (!pThread || pThread->m_nThreadID != ACE_OS::thr_self ()) - ACE_ENDTHREADEX (status); - else - ::AfxEndThread ((DWORD)status); - } -# else - - ACE_ENDTHREADEX (status); -# endif /* ACE_HAS_MFC && ACE_HAS_MFS != 0*/ -# endif /* ACE_WIN32 */ -#endif /* ACE_WIN32 || ACE_HAS_TSS_EMULATION */ - } - - return status; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Thread_Adapter.h b/deps/acelite/ace/Thread_Adapter.h deleted file mode 100644 index 660f120e6..000000000 --- a/deps/acelite/ace/Thread_Adapter.h +++ /dev/null @@ -1,97 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Thread_Adapter.h - * - * @author Carlos O'Ryan - */ -//============================================================================= - -#ifndef ACE_THREAD_ADAPTER_H -#define ACE_THREAD_ADAPTER_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Base_Thread_Adapter.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward decl. -class ACE_Thread_Manager; -class ACE_Thread_Descriptor; - -/** - * @class ACE_Thread_Adapter - * - * @brief Converts a C++ function into a function that - * can be called from a thread creation routine - * (e.g., pthread_create() or _beginthreadex()) that expects an - * extern "C" entry point. This class also makes it possible to - * transparently provide hooks to register a thread with an - * ACE_Thread_Manager. - * - * This class is used in ACE_OS::thr_create(). In general, the - * thread that creates an object of this class is different from - * the thread that calls @c invoke() on this object. Therefore, - * the @c invoke() method is responsible for deleting itself. - */ -class ACE_Export ACE_Thread_Adapter : public ACE_Base_Thread_Adapter -{ -public: - /// Constructor. - ACE_Thread_Adapter (ACE_THR_FUNC user_func, - void *arg, - ACE_THR_C_FUNC entry_point = (ACE_THR_C_FUNC) ACE_THREAD_ADAPTER_NAME, - ACE_Thread_Manager *thr_mgr = 0, - ACE_Thread_Descriptor *td = 0 -# if defined (ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS) - , ACE_SEH_EXCEPT_HANDLER selector = 0, - ACE_SEH_EXCEPT_HANDLER handler = 0 -# endif /* ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS */ - , long cancel_flags = 0 - ); - - /** - * Execute the with the . This function deletes - * @c this, thereby rendering the object useless after the call - * returns. - */ - virtual ACE_THR_FUNC_RETURN invoke (void); - - /// Accessor for the optional ACE_Thread_Manager. - ACE_Thread_Manager *thr_mgr (void); - - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Ensure that this object must be allocated on the heap. - ~ACE_Thread_Adapter (void); - -private: - /// Called by invoke, mainly here to separate the SEH stuff because - /// SEH on Win32 doesn't compile with local vars with destructors. - virtual ACE_THR_FUNC_RETURN invoke_i (void); - -private: - /// Optional thread manager. - ACE_Thread_Manager *thr_mgr_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -# if defined (ACE_HAS_INLINED_OSCALLS) -# if defined (ACE_INLINE) -# undef ACE_INLINE -# endif /* ACE_INLINE */ -# define ACE_INLINE inline -# include "ace/Thread_Adapter.inl" -# endif /* ACE_HAS_INLINED_OSCALLS */ - -#include /**/ "ace/post.h" -#endif /* ACE_THREAD_ADAPTER_H */ diff --git a/deps/acelite/ace/Thread_Adapter.inl b/deps/acelite/ace/Thread_Adapter.inl deleted file mode 100644 index 06751eecd..000000000 --- a/deps/acelite/ace/Thread_Adapter.inl +++ /dev/null @@ -1,10 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE ACE_Thread_Manager * -ACE_Thread_Adapter::thr_mgr (void) -{ - return this->thr_mgr_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Thread_Control.cpp b/deps/acelite/ace/Thread_Control.cpp deleted file mode 100644 index c00234e5f..000000000 --- a/deps/acelite/ace/Thread_Control.cpp +++ /dev/null @@ -1,80 +0,0 @@ -#include "ace/Thread_Control.h" -#include "ace/Thread_Manager.h" - -#if !defined (ACE_HAS_INLINED_OSCALLS) -# include "ace/Thread_Control.inl" -#endif /* ACE_HAS_INLINED_OSCALLS */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -void -ACE_Thread_Control::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_OS_TRACE ("ACE_Thread_Control::dump"); -#endif /* ACE_HAS_DUMP */ -} - -int -ACE_Thread_Control::insert (ACE_Thread_Manager *tm, bool insert) -{ - ACE_OS_TRACE ("ACE_Thread_Control::insert"); - - ACE_hthread_t t_id; - ACE_OS::thr_self (t_id); - this->tm_ = tm; - - if (insert) - return this->tm_->insert_thr (ACE_OS::thr_self (), t_id); - else - return 0; -} - -// Initialize the thread controller. -ACE_Thread_Control::ACE_Thread_Control (ACE_Thread_Manager *t, - int insert) - : tm_ (t), - status_ (0) -{ - ACE_OS_TRACE ("ACE_Thread_Control::ACE_Thread_Control"); - - if (this->tm_ != 0 && insert) - { - ACE_hthread_t t_id; - ACE_OS::thr_self (t_id); - this->tm_->insert_thr (ACE_OS::thr_self (), t_id); - } -} - -// Automatically kill thread on exit. -ACE_Thread_Control::~ACE_Thread_Control (void) -{ - ACE_OS_TRACE ("ACE_Thread_Control::~ACE_Thread_Control"); - -#if defined (ACE_HAS_RECURSIVE_THR_EXIT_SEMANTICS) || defined (ACE_HAS_TSS_EMULATION) || defined (ACE_WIN32) - this->exit (this->status_, 0); -#else - this->exit (this->status_, 1); -#endif /* ACE_HAS_RECURSIVE_THR_EXIT_SEMANTICS */ -} - -// Exit from thread (but clean up first). -ACE_THR_FUNC_RETURN -ACE_Thread_Control::exit (ACE_THR_FUNC_RETURN exit_status, int do_thr_exit) -{ - ACE_OS_TRACE ("ACE_Thread_Control::exit"); - - if (this->tm_ != 0) - return this->tm_->exit (exit_status, do_thr_exit); - else - { -#if !defined (ACE_HAS_TSS_EMULATION) - // With ACE_HAS_TSS_EMULATION, we let ACE_Thread_Adapter::invoke () - // exit the thread after cleaning up TSS. - ACE_OS::thr_exit (exit_status); -#endif /* ! ACE_HAS_TSS_EMULATION */ - return 0; - } -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Thread_Control.h b/deps/acelite/ace/Thread_Control.h deleted file mode 100644 index a392d83a5..000000000 --- a/deps/acelite/ace/Thread_Control.h +++ /dev/null @@ -1,99 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Thread_Control.h - * - * @author Carlos O'Ryan - */ -//============================================================================= - -#ifndef ACE_THREAD_CONTROL_H -#define ACE_THREAD_CONTROL_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -class ACE_Thread_Manager; - -/** - * @class ACE_Thread_Control - * - * @brief Used to keep track of a thread's activities within its entry - * point function. - * - * A ACE_Thread_Manager uses this class to ensure that threads - * it spawns automatically register and unregister themselves - * with it. - * This class can be stored in thread-specific storage using the - * ACE_TSS wrapper. When a thread exits the - * function deletes this object, thereby - * ensuring that it gets removed from its associated - * ACE_Thread_Manager. - */ -class ACE_Export ACE_Thread_Control -{ -public: - /// Initialize the thread control object. If @a insert != 0, then - /// register the thread with the Thread_Manager. - ACE_Thread_Control (ACE_Thread_Manager *tm = 0, - int insert = 0); - - /// Remove the thread from its associated Thread_Manager and exit - /// the thread if is enabled. - ~ACE_Thread_Control (void); - - /// Remove this thread from its associated ACE_Thread_Manager and exit - /// the thread if @a do_thr_exit is enabled. - ACE_THR_FUNC_RETURN exit (ACE_THR_FUNC_RETURN status, - int do_thr_exit); - - /// Store the Thread_Manager and use it to register ourselves for - /// correct shutdown. - int insert (ACE_Thread_Manager *tm, bool insert = false); - - /// Returns the current Thread_Manager. - ACE_Thread_Manager *thr_mgr (void); - - /// Atomically set a new Thread_Manager and return the old - /// Thread_Manager. - ACE_Thread_Manager *thr_mgr (ACE_Thread_Manager *); - - /// Set the exit status (and return existing status). - ACE_THR_FUNC_RETURN status (ACE_THR_FUNC_RETURN status); - - /// Get the current exit status. - ACE_THR_FUNC_RETURN status (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Pointer to the thread manager for this block of code. - ACE_Thread_Manager *tm_; - - /// Keeps track of the exit status for the thread. - ACE_THR_FUNC_RETURN status_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -# if defined (ACE_HAS_INLINED_OSCALLS) -# if defined (ACE_INLINE) -# undef ACE_INLINE -# endif /* ACE_INLINE */ -# define ACE_INLINE inline -# include "ace/Thread_Control.inl" -# endif /* ACE_HAS_INLINED_OSCALLS */ - -#include /**/ "ace/post.h" -#endif /* ACE_THREAD_CONTROL_H */ diff --git a/deps/acelite/ace/Thread_Control.inl b/deps/acelite/ace/Thread_Control.inl deleted file mode 100644 index 20d03fe78..000000000 --- a/deps/acelite/ace/Thread_Control.inl +++ /dev/null @@ -1,45 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_macros.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Set the exit status. - -ACE_INLINE ACE_THR_FUNC_RETURN -ACE_Thread_Control::status (ACE_THR_FUNC_RETURN s) -{ - ACE_OS_TRACE ("ACE_Thread_Control::status"); - return this->status_ = s; -} - -// Get the exit status. - -ACE_INLINE ACE_THR_FUNC_RETURN -ACE_Thread_Control::status (void) -{ - ACE_OS_TRACE ("ACE_Thread_Control::status"); - return this->status_; -} - -// Returns the current . - -ACE_INLINE ACE_Thread_Manager * -ACE_Thread_Control::thr_mgr (void) -{ - ACE_OS_TRACE ("ACE_Thread_Control::thr_mgr"); - return this->tm_; -} - -// Atomically set a new and return the old -// . - -ACE_INLINE ACE_Thread_Manager * -ACE_Thread_Control::thr_mgr (ACE_Thread_Manager *tm) -{ - ACE_OS_TRACE ("ACE_Thread_Control::thr_mgr"); - ACE_Thread_Manager *o_tm = this->tm_; - this->tm_ = tm; - return o_tm; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Thread_Exit.cpp b/deps/acelite/ace/Thread_Exit.cpp deleted file mode 100644 index 0d35cdba2..000000000 --- a/deps/acelite/ace/Thread_Exit.cpp +++ /dev/null @@ -1,121 +0,0 @@ -#include "ace/Thread_Exit.h" -#include "ace/Managed_Object.h" -#include "ace/Thread_Manager.h" -#include "ace/Guard_T.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -bool ACE_Thread_Exit::is_constructed_ = false; - -void -ACE_Thread_Exit::cleanup (void *instance) -{ - ACE_OS_TRACE ("ACE_Thread_Exit::cleanup"); - - delete (ACE_TSS_TYPE (ACE_Thread_Exit) *) instance; - - // Set the thr_exit_ static to null to keep things from crashing if - // ACE::fini() is enabled here. - ACE_Thread_Manager::thr_exit_ = 0; - - ACE_Thread_Exit::is_constructed_ = false; - // All TSS objects have been destroyed. Reset this flag so - // ACE_Thread_Exit singleton can be created again. -} - -// NOTE: this preprocessor directive should match the one in -// ACE_Task_Base::svc_run () below. This prevents the two statics -// from being defined. - -ACE_Thread_Exit * -ACE_Thread_Exit::instance (void) -{ -#if defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION) - ACE_OS_TRACE ("ACE_Thread_Exit::instance"); - - // Determines if we were dynamically allocated. - static ACE_TSS_TYPE (ACE_Thread_Exit) * volatile instance_; - - // Implement the Double Check pattern. - - if (!ACE_Thread_Exit::is_constructed_) - { - ACE_MT (ACE_Thread_Mutex *lock = - ACE_Managed_Object::get_preallocated_object - (ACE_Object_Manager::ACE_THREAD_EXIT_LOCK); - ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, *lock, 0)); - - if (!ACE_Thread_Exit::is_constructed_) - { - ACE_NEW_RETURN (instance_, - ACE_TSS_TYPE (ACE_Thread_Exit), - 0); - - ACE_Thread_Exit::is_constructed_ = true; - - ACE_Thread_Manager::set_thr_exit (instance_); - } - } - - return ACE_TSS_GET (instance_, ACE_Thread_Exit); -#else - return 0; -#endif /* ACE_HAS_THREAD_SPECIFIC_STORAGE || ACE_HAS_TSS_EMULATION */ -} - -// Grab hold of the Task * so that we can close() it in the -// destructor. - -ACE_Thread_Exit::ACE_Thread_Exit (void) -{ - ACE_OS_TRACE ("ACE_Thread_Exit::ACE_Thread_Exit"); -} - -// Set the this pointer... - -void -ACE_Thread_Exit::thr_mgr (ACE_Thread_Manager *tm) -{ - ACE_OS_TRACE ("ACE_Thread_Exit::thr_mgr"); - - if (tm != 0) - this->thread_control_.insert (tm, 0); -} - -// When this object is destroyed the Task is automatically closed -// down! - -ACE_Thread_Exit::~ACE_Thread_Exit (void) -{ - ACE_OS_TRACE ("ACE_Thread_Exit::~ACE_Thread_Exit"); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Exit) - -ACE_Thread_Exit_Maybe::ACE_Thread_Exit_Maybe (int flag) - : instance_ (0) -{ - if (flag) - { - ACE_NEW (instance_, ACE_Thread_Exit); - } -} - -ACE_Thread_Exit_Maybe::~ACE_Thread_Exit_Maybe (void) -{ - delete this->instance_; -} - -ACE_Thread_Exit * -ACE_Thread_Exit_Maybe::operator -> (void) const -{ - return this->instance_; -} - -ACE_Thread_Exit * -ACE_Thread_Exit_Maybe::instance (void) const -{ - return this->instance_; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Thread_Exit.h b/deps/acelite/ace/Thread_Exit.h deleted file mode 100644 index a6ac6516c..000000000 --- a/deps/acelite/ace/Thread_Exit.h +++ /dev/null @@ -1,111 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Thread_Exit.h - * - * @author Carlos O'Ryan - */ -//============================================================================= - - -#ifndef ACE_THREAD_EXIT_H -#define ACE_THREAD_EXIT_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Thread_Control.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Thread_Exit - * - * @brief Keep exit information for a Thread in thread specific storage. - * so that the thread-specific exit hooks will get called no - * matter how the thread exits (e.g., via , C++ - * or Win32 exception, "falling off the end" of the thread entry - * point function, etc.). - * - * This clever little helper class is stored in thread-specific - * storage using the wrapper. When a thread exits the - * function deletes this object, thereby - * closing it down gracefully. - */ -class ACE_Export ACE_Thread_Exit -{ -public: - /// Capture the Thread that will be cleaned up automatically. - ACE_Thread_Exit (void); - - /// Set the ACE_Thread_Manager. - void thr_mgr (ACE_Thread_Manager *tm); - - /// Destructor calls the thread-specific exit hooks when a thread - /// exits. - ~ACE_Thread_Exit (void); - - /// Singleton access point. - static ACE_Thread_Exit *instance (void); - - /// Cleanup method, used by the ACE_Object_Manager to destroy the - /// singleton. - static void cleanup (void *instance); - - ACE_ALLOC_HOOK_DECLARE; - -private: - /// Automatically add/remove the thread from the - /// ACE_Thread_Manager. - ACE_Thread_Control thread_control_; - - /** - * Used to detect whether we should create a new instance (or not) - * within the instance method -- we don't trust the instance_ ptr - * because the destructor may have run (if ACE::fini() was called). - * See bug #526. - * We don't follow the singleton pattern due to dependency issues. - */ - static bool is_constructed_; -}; - -/** - * @class ACE_Thread_Exit_Maybe - * - * @brief A version of ACE_Thread_Exit that is created dynamically - * under the hood if the flag is set to TRUE. - * - * Allows the appearance of a "smart pointer", but is not - * always created. - */ -class ACE_Export ACE_Thread_Exit_Maybe -{ -public: - /// Don't create an ACE_Thread_Exit instance by default. - ACE_Thread_Exit_Maybe (int flag = 0); - - /// Destroys the underlying ACE_Thread_Exit instance if it exists. - ~ACE_Thread_Exit_Maybe (void); - - /// Delegates to underlying instance. - ACE_Thread_Exit * operator -> (void) const; - - /// Returns the underlying instance. - ACE_Thread_Exit * instance (void) const; - -private: - - /// Holds the underlying instance. - ACE_Thread_Exit *instance_; - -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" -#endif /* ACE_THREAD_EXIT_H */ diff --git a/deps/acelite/ace/Thread_Hook.cpp b/deps/acelite/ace/Thread_Hook.cpp deleted file mode 100644 index f1b07e392..000000000 --- a/deps/acelite/ace/Thread_Hook.cpp +++ /dev/null @@ -1,32 +0,0 @@ -#include "ace/Thread_Hook.h" -#include "ace/Object_Manager_Base.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Thread_Hook::ACE_Thread_Hook() -{ -} - -ACE_Thread_Hook::~ACE_Thread_Hook () -{ -} - -ACE_THR_FUNC_RETURN -ACE_Thread_Hook::start (ACE_THR_FUNC func, void *arg) -{ - return (func) (arg); -} - -ACE_Thread_Hook * -ACE_Thread_Hook::thread_hook (ACE_Thread_Hook *hook) -{ - return ACE_OS_Object_Manager::thread_hook (hook); -} - -ACE_Thread_Hook * -ACE_Thread_Hook::thread_hook (void) -{ - return ACE_OS_Object_Manager::thread_hook (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Thread_Hook.h b/deps/acelite/ace/Thread_Hook.h deleted file mode 100644 index dcb6d396e..000000000 --- a/deps/acelite/ace/Thread_Hook.h +++ /dev/null @@ -1,63 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Thread_Hook.h - * - * @author Carlos O'Ryan - */ -//============================================================================= - -#ifndef ACE_THREAD_HOOK_H -#define ACE_THREAD_HOOK_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include /**/ "ace/ACE_export.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Thread_Hook - * - * @brief This class makes it possible to provide user-defined "start" - * hooks that are called before the thread entry point function - * is invoked. - */ -class ACE_Export ACE_Thread_Hook -{ -public: - /// Default constructor - ACE_Thread_Hook (void); - - /// Destructor. - virtual ~ACE_Thread_Hook (void); - - /** - * This method can be overridden in a subclass to customize this - * pre-function call "hook" invocation that can perform - * initialization processing before the thread entry point @a func - * method is called back. The @a func and @a arg passed into the - * start hook are the same as those passed by the application that - * spawned the thread. - */ - virtual ACE_THR_FUNC_RETURN start (ACE_THR_FUNC func, - void *arg); - - /// Sets the system wide thread hook, returns the previous thread - /// hook or 0 if none is set. - static ACE_Thread_Hook *thread_hook (ACE_Thread_Hook *hook); - - /// Returns the current system thread hook. - static ACE_Thread_Hook *thread_hook (void); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" -#endif /* ACE_THREAD_HOOK_H */ diff --git a/deps/acelite/ace/Thread_Manager.cpp b/deps/acelite/ace/Thread_Manager.cpp deleted file mode 100644 index 172e4a43a..000000000 --- a/deps/acelite/ace/Thread_Manager.cpp +++ /dev/null @@ -1,2379 +0,0 @@ -#include "ace/TSS_T.h" -#include "ace/Thread_Manager.h" -#include "ace/Dynamic.h" -#include "ace/Object_Manager.h" -#include "ace/Singleton.h" -#include "ace/Auto_Ptr.h" -#include "ace/Guard_T.h" -#include "ace/Time_Value.h" -#include "ace/OS_NS_sys_time.h" -#include "ace/Truncate.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Thread_Manager.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_At_Thread_Exit::~ACE_At_Thread_Exit (void) -{ - this->do_apply (); -} - -ACE_At_Thread_Exit_Func::~ACE_At_Thread_Exit_Func (void) -{ - this->do_apply (); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_At_Thread_Exit_Func) - -void -ACE_At_Thread_Exit_Func::apply (void) -{ - this->func_ (this->object_, this->param_); -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Control) -ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Manager) - -#if ! defined (ACE_THREAD_MANAGER_LACKS_STATICS) -// Process-wide Thread Manager. -ACE_Thread_Manager *ACE_Thread_Manager::thr_mgr_ = 0; - -// Controls whether the Thread_Manager is deleted when we shut down -// (we can only delete it safely if we created it!) -bool ACE_Thread_Manager::delete_thr_mgr_ = false; -#endif /* ! defined (ACE_THREAD_MANAGER_LACKS_STATICS) */ - -ACE_TSS_TYPE (ACE_Thread_Exit) *ACE_Thread_Manager::thr_exit_ = 0; - -int -ACE_Thread_Manager::set_thr_exit (ACE_TSS_TYPE (ACE_Thread_Exit) *ptr) -{ - if (ACE_Thread_Manager::thr_exit_ == 0) - ACE_Thread_Manager::thr_exit_ = ptr; - else - return -1; - return 0; -} - -void -ACE_Thread_Manager::dump (void) -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Thread_Manager::dump"); - // Cast away const-ness of this in order to use its non-const lock_. - ACE_MT (ACE_GUARD (ACE_Thread_Mutex, ace_mon, - ((ACE_Thread_Manager *) this)->lock_)); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\ngrp_id_ = %d"), this->grp_id_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\ncurrent_count_ = %d"), this->thr_list_.size ())); - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - iter.next ()->dump (); - } - - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Thread_Descriptor::~ACE_Thread_Descriptor (void) -{ - delete this->sync_; -} - -void -ACE_Thread_Descriptor::at_pop (int apply) -{ - ACE_TRACE ("ACE_Thread_Descriptor::at_pop"); - // Get first at from at_exit_list - ACE_At_Thread_Exit* at = this->at_exit_list_; - // Remove at from at_exit list - this->at_exit_list_ = at->next_; - // Apply if required - if (apply) - { - at->apply (); - // Do the apply method - at->was_applied (true); - // Mark at has been applied to avoid double apply from - // at destructor - } - // If at is not owner delete at. - if (!at->is_owner ()) - delete at; -} - -void -ACE_Thread_Descriptor::at_push (ACE_At_Thread_Exit* cleanup, bool is_owner) -{ - ACE_TRACE ("ACE_Thread_Descriptor::at_push"); - cleanup->is_owner (is_owner); - cleanup->td_ = this; - cleanup->next_ = at_exit_list_; - at_exit_list_ = cleanup; -} - -int -ACE_Thread_Descriptor::at_exit (ACE_At_Thread_Exit& cleanup) -{ - ACE_TRACE ("ACE_Thread_Descriptor::at_exit"); - at_push (&cleanup, 1); - return 0; -} - -int -ACE_Thread_Descriptor::at_exit (ACE_At_Thread_Exit* cleanup) -{ - ACE_TRACE ("ACE_Thread_Descriptor::at_exit"); - if (cleanup==0) - return -1; - else - { - this->at_push (cleanup); - return 0; - } -} - -void -ACE_Thread_Descriptor::do_at_exit () -{ - ACE_TRACE ("ACE_Thread_Descriptor::do_at_exit"); - while (at_exit_list_!=0) - this->at_pop (); -} - -void -ACE_Thread_Descriptor::terminate () -{ - ACE_TRACE ("ACE_Thread_Descriptor::terminate"); - - if (!terminated_) - { - ACE_Log_Msg* log_msg = this->log_msg_; - terminated_ = true; - // Run at_exit hooks - this->do_at_exit (); - // We must remove Thread_Descriptor from Thread_Manager list - if (this->tm_ != 0) - { - int close_handle = 0; - -#if !defined (ACE_HAS_VXTHREADS) - // Threads created with THR_DAEMON shouldn't exist here, but - // just to be safe, let's put it here. - - if (ACE_BIT_DISABLED (this->thr_state_, ACE_Thread_Manager::ACE_THR_JOINING)) - { - if (ACE_BIT_DISABLED (this->flags_, THR_DETACHED | THR_DAEMON) - || ACE_BIT_ENABLED (this->flags_, THR_JOINABLE)) - { - // Mark thread as terminated. - ACE_SET_BITS (this->thr_state_, ACE_Thread_Manager::ACE_THR_TERMINATED); - tm_->register_as_terminated (this); - // Must copy the information here because td will be - // "freed" below. - } -#if defined (ACE_WIN32) - else - { - close_handle = 1; - } -#endif /* ACE_WIN32 */ - } -#endif /* !ACE_HAS_VXTHREADS */ - - // Remove thread descriptor from the table. 'this' is invalid - // upon return. - if (this->tm_ != 0) - { - // remove_thr makes use of 'this' invalid on return. - // Code below will free log_msg, so clear our pointer - // now - it's already been saved in log_msg. - this->log_msg_ = 0; - tm_->remove_thr (this, close_handle); - } - } - - // Check if we need delete ACE_Log_Msg instance - // If ACE_TSS_cleanup was not executed first log_msg == 0 - if (log_msg == 0) - { - // Only inform to ACE_TSS_cleanup that it must delete the log instance - // setting ACE_LOG_MSG thr_desc to 0. - ACE_LOG_MSG->thr_desc (0); - } - else - { - delete log_msg; - } - } -} - -int -ACE_Thread_Descriptor::at_exit (void *object, - ACE_CLEANUP_FUNC cleanup_hook, - void *param) -{ - ACE_TRACE ("ACE_Thread_Descriptor::at_exit"); - // To keep compatibility, when cleanup_hook is null really is a at_pop - // without apply. - if (cleanup_hook == 0) - { - if (this->at_exit_list_!= 0) - this->at_pop(0); - } - else - { - ACE_At_Thread_Exit* cleanup = 0; - ACE_NEW_RETURN (cleanup, - ACE_At_Thread_Exit_Func (object, - cleanup_hook, - param), - -1); - this->at_push (cleanup); - } - return 0; -} - -void -ACE_Thread_Descriptor::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Thread_Descriptor::dump"); - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nthr_id_ = %d"), this->thr_id_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nthr_handle_ = %d"), this->thr_handle_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\ngrp_id_ = %d"), this->grp_id_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nthr_state_ = %d"), this->thr_state_)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\nflags_ = %x\n"), this->flags_)); - - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Thread_Descriptor::ACE_Thread_Descriptor (void) - : log_msg_ (0), - at_exit_list_ (0), - tm_ (0), - terminated_ (false) -{ - ACE_TRACE ("ACE_Thread_Descriptor::ACE_Thread_Descriptor"); - ACE_NEW (this->sync_, - ACE_DEFAULT_THREAD_MANAGER_LOCK); -} - -void -ACE_Thread_Descriptor::acquire_release (void) -{ - // Just try to acquire the lock then release it. -#if defined (ACE_THREAD_MANAGER_USES_SAFE_SPAWN) - if (ACE_BIT_DISABLED (this->thr_state_, ACE_Thread_Manager::ACE_THR_SPAWNED)) -#endif /* ACE_THREAD_MANAGER_USES_SAFE_SPAWN */ - { - this->sync_->acquire (); - // Acquire the lock before removing from the thread table. If - // this thread is in the table already, it should simply acquire the - // lock easily. - - // Once we get the lock, we must have registered. - ACE_ASSERT (ACE_BIT_ENABLED (this->thr_state_, ACE_Thread_Manager::ACE_THR_SPAWNED)); - - this->sync_->release (); - // Release the lock before putting it back to freelist. - } -} - -void -ACE_Thread_Descriptor::acquire (void) -{ - // Just try to acquire the lock then release it. -#if defined (ACE_THREAD_MANAGER_USES_SAFE_SPAWN) - if (ACE_BIT_DISABLED (this->thr_state_, ACE_Thread_Manager::ACE_THR_SPAWNED)) -#endif /* ACE_THREAD_MANAGER_USES_SAFE_SPAWN */ - { - this->sync_->acquire (); - } -} - -void -ACE_Thread_Descriptor::release (void) -{ - // Just try to acquire the lock then release it. -#if defined (ACE_THREAD_MANAGER_USES_SAFE_SPAWN) - if (ACE_BIT_DISABLED (this->thr_state_, ACE_Thread_Manager::ACE_THR_SPAWNED)) -#endif /* ACE_THREAD_MANAGER_USES_SAFE_SPAWN */ - { - this->sync_->release (); - // Release the lock before putting it back to freelist. - } -} - -// The following macro simplifies subsequence code. -#define ACE_FIND(OP,INDEX) \ - ACE_Thread_Descriptor *INDEX = OP; \ - -ACE_Thread_Descriptor * -ACE_Thread_Manager::thread_descriptor (ACE_thread_t thr_id) -{ - ACE_TRACE ("ACE_Thread_Manager::thread_descriptor"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); - - ACE_FIND (this->find_thread (thr_id), ptr); - return ptr; -} - -ACE_Thread_Descriptor * -ACE_Thread_Manager::hthread_descriptor (ACE_hthread_t thr_handle) -{ - ACE_TRACE ("ACE_Thread_Manager::hthread_descriptor"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); - - ACE_FIND (this->find_hthread (thr_handle), ptr); - return ptr; -} - -// Return the thread descriptor (indexed by ACE_hthread_t). - -int -ACE_Thread_Manager::thr_self (ACE_hthread_t &self) -{ - ACE_TRACE ("ACE_Thread_Manager::thr_self"); - - ACE_Thread_Descriptor *desc = - this->thread_desc_self (); - - if (desc == 0) - return -1; - else - desc->self (self); - - return 0; -} - -// Initialize the synchronization variables. - -ACE_Thread_Manager::ACE_Thread_Manager (size_t prealloc, - size_t lwm, - size_t inc, - size_t hwm) - : grp_id_ (1), - automatic_wait_ (1) -#if defined (ACE_HAS_THREADS) - , zero_cond_ (lock_) -#endif /* ACE_HAS_THREADS */ - , thread_desc_freelist_ (ACE_FREE_LIST_WITH_POOL, - prealloc, lwm, hwm, inc) -#if defined (ACE_HAS_THREADS) && defined (ACE_LACKS_PTHREAD_JOIN) - , join_cond_ (this->lock_) -#endif -{ - ACE_TRACE ("ACE_Thread_Manager::ACE_Thread_Manager"); -} - -ACE_Thread_Manager::ACE_Thread_Manager (const ACE_Condition_Attributes &attributes, - size_t prealloc, - size_t lwm, - size_t inc, - size_t hwm) - : grp_id_ (1), - automatic_wait_ (1) -#if defined (ACE_HAS_THREADS) - , zero_cond_ (lock_, attributes) -#endif /* ACE_HAS_THREADS */ - , thread_desc_freelist_ (ACE_FREE_LIST_WITH_POOL, - prealloc, lwm, hwm, inc) -#if defined (ACE_HAS_THREADS) && defined (ACE_LACKS_PTHREAD_JOIN) - , join_cond_ (this->lock_) -#endif -{ -#if !defined (ACE_HAS_THREADS) - ACE_UNUSED_ARG (attributes); -#endif /* ACE_HAS_THREADS */ - ACE_TRACE ("ACE_Thread_Manager::ACE_Thread_Manager"); -} - -#if ! defined (ACE_THREAD_MANAGER_LACKS_STATICS) -ACE_Thread_Manager * -ACE_Thread_Manager::instance (void) -{ - ACE_TRACE ("ACE_Thread_Manager::instance"); - - if (ACE_Thread_Manager::thr_mgr_ == 0) - { - // Perform Double-Checked Locking Optimization. - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, - *ACE_Static_Object_Lock::instance (), 0)); - - if (ACE_Thread_Manager::thr_mgr_ == 0) - { - ACE_NEW_RETURN (ACE_Thread_Manager::thr_mgr_, - ACE_Thread_Manager, - 0); - ACE_Thread_Manager::delete_thr_mgr_ = true; - } - } - - return ACE_Thread_Manager::thr_mgr_; -} - -ACE_Thread_Manager * -ACE_Thread_Manager::instance (ACE_Thread_Manager *tm) -{ - ACE_TRACE ("ACE_Thread_Manager::instance"); - ACE_MT (ACE_GUARD_RETURN (ACE_Recursive_Thread_Mutex, ace_mon, - *ACE_Static_Object_Lock::instance (), 0)); - - ACE_Thread_Manager *t = ACE_Thread_Manager::thr_mgr_; - // We can't safely delete it since we don't know who created it! - ACE_Thread_Manager::delete_thr_mgr_ = false; - - ACE_Thread_Manager::thr_mgr_ = tm; - return t; -} - -void -ACE_Thread_Manager::close_singleton (void) -{ - ACE_TRACE ("ACE_Thread_Manager::close_singleton"); - - ACE_MT (ACE_GUARD (ACE_Recursive_Thread_Mutex, ace_mon, - *ACE_Static_Object_Lock::instance ())); - - if (ACE_Thread_Manager::delete_thr_mgr_) - { - // First, we clean up the thread descriptor list. - ACE_Thread_Manager::thr_mgr_->close (); - delete ACE_Thread_Manager::thr_mgr_; - ACE_Thread_Manager::thr_mgr_ = 0; - ACE_Thread_Manager::delete_thr_mgr_ = false; - } - - ACE_Thread_Exit::cleanup (ACE_Thread_Manager::thr_exit_); -} -#endif /* ! defined (ACE_THREAD_MANAGER_LACKS_STATICS) */ - -// Close up and release all resources. - -int -ACE_Thread_Manager::close () -{ - ACE_TRACE ("ACE_Thread_Manager::close"); - - // Clean up the thread descriptor list. - if (this->automatic_wait_) - this->wait (0, 1); - else - { - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - this->remove_thr_all (); - } - - return 0; -} - -ACE_Thread_Manager::~ACE_Thread_Manager (void) -{ - ACE_TRACE ("ACE_Thread_Manager::~ACE_Thread_Manager"); - this->close (); -} - - -// Run the entry point for thread spawned under the control of the -// . This must be an extern "C" to make certain -// compilers happy... -// -// The interaction with and -// works like this, with -// ACE_HAS_THREAD_SPECIFIC_STORAGE or ACE_HAS_TSS_EMULATION: -// -// o Every thread in the is run with -// . -// -// o retrieves the singleton -// instance from . -// The singleton gets created in thread-specific storage -// in the first call to that function. The key point is that the -// instance is in thread-specific storage. -// -// o A thread can exit by various means, such as , C++ -// or Win32 exception, "falling off the end" of the thread entry -// point function, etc. -// -// o If you follow this so far, now it gets really fun . . . -// When the thread-specific storage (for the thread that -// is being destroyed) is cleaned up, the OS threads package (or -// the ACE emulation of thread-specific storage) will destroy any -// objects that are in thread-specific storage. It has a list of -// them, and just walks down the list and destroys each one. -// -// o That's where the ACE_Thread_Exit destructor gets called. - -#if defined(ACE_USE_THREAD_MANAGER_ADAPTER) -extern "C" void * -ace_thread_manager_adapter (void *args) -{ -#if defined (ACE_HAS_TSS_EMULATION) - // As early as we can in the execution of the new thread, allocate - // its local TS storage. Allocate it on the stack, to save dynamic - // allocation/dealloction. - void *ts_storage[ACE_TSS_Emulation::ACE_TSS_THREAD_KEYS_MAX]; - ACE_TSS_Emulation::tss_open (ts_storage); -#endif /* ACE_HAS_TSS_EMULATION */ - - ACE_Thread_Adapter *thread_args = reinterpret_cast (args); - - // NOTE: this preprocessor directive should match the one in above - // ACE_Thread_Exit::instance (). With the Xavier Pthreads package, - // the exit_hook in TSS causes a seg fault. So, this works around - // that by creating exit_hook on the stack. -#if defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION) - // Obtain our thread-specific exit hook and make sure that it knows - // how to clean us up! Note that we never use this pointer directly - // (it's stored in thread-specific storage), so it's ok to - // dereference it here and only store it as a reference. - ACE_Thread_Exit &exit_hook = *ACE_Thread_Exit::instance (); -#else - // Without TSS, create an instance. When this - // function returns, its destructor will be called because the - // object goes out of scope. The drawback with this appraoch is - // that the destructor _won't_ get called if is called. - // So, threads shouldn't exit that way. Instead, they should return - // from . - ACE_Thread_Exit exit_hook; -#endif /* ACE_HAS_THREAD_SPECIFIC_STORAGE || ACE_HAS_TSS_EMULATION */ - - // Keep track of the that's associated with this - // . - exit_hook.thr_mgr (thread_args->thr_mgr ()); - - // Invoke the user-supplied function with the args. - ACE_THR_FUNC_RETURN status = thread_args->invoke (); - - delete static_cast (thread_args); - - return reinterpret_cast (status); -} -#endif - -// Call the appropriate OS routine to spawn a thread. Should *not* be -// called with the lock_ held... - -int -ACE_Thread_Manager::spawn_i (ACE_THR_FUNC func, - void *args, - long flags, - ACE_thread_t *t_id, - ACE_hthread_t *t_handle, - long priority, - int grp_id, - void *stack, - size_t stack_size, - ACE_Task_Base *task, - const char** thr_name) -{ - // First, threads created by Thread Manager should not be daemon threads. - // Using assertion is probably a bit too strong. However, it helps - // finding this kind of error as early as possible. Perhaps we can replace - // assertion by returning error. - ACE_ASSERT (ACE_BIT_DISABLED (flags, THR_DAEMON)); - - // Create a new thread running . *Must* be called with the - // held... - // Get a "new" Thread Descriptor from the freelist. -#if defined (ACE_HAS_CPP11) - std::unique_ptr new_thr_desc (this->thread_desc_freelist_.remove ()); -#else - auto_ptr new_thr_desc (this->thread_desc_freelist_.remove ()); -#endif /* ACE_HAS_CPP11 */ - - // Reset thread descriptor status - new_thr_desc->reset (this); - - ACE_Thread_Adapter *thread_args = 0; -# if defined (ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS) - ACE_NEW_RETURN (thread_args, - ACE_Thread_Adapter (func, - args, - (ACE_THR_C_FUNC) ACE_THREAD_ADAPTER_NAME, - this, - new_thr_desc.get (), - ACE_OS_Object_Manager::seh_except_selector(), - ACE_OS_Object_Manager::seh_except_handler(), - flags), - -1); -# else - ACE_NEW_RETURN (thread_args, - ACE_Thread_Adapter (func, - args, - (ACE_THR_C_FUNC) ACE_THREAD_ADAPTER_NAME, - this, - new_thr_desc.get (), - flags), - -1); -# endif /* ACE_HAS_WIN32_STRUCTURAL_EXCEPTIONS */ -#if defined ACE_HAS_CPP11 - std::unique_ptr auto_thread_args (static_cast (thread_args)); -#else - auto_ptr auto_thread_args (static_cast (thread_args)); -#endif - - ACE_TRACE ("ACE_Thread_Manager::spawn_i"); - ACE_hthread_t thr_handle; - - ACE_thread_t thr_id; - if (t_id == 0) - t_id = &thr_id; - - // Acquire the lock to block the spawned thread from - // removing this Thread Descriptor before it gets put into our - // thread table. - new_thr_desc->sync_->acquire (); - - int const result = ACE_Thread::spawn (func, - args, - flags, - t_id, - &thr_handle, - priority, - stack, - stack_size, - thread_args, - thr_name); - - if (result != 0) - { - // _Don't_ clobber errno here! result is either 0 or -1, and - // ACE_OS::thr_create () already set errno! D. Levine 28 Mar 1997 - // errno = result; - ACE_Errno_Guard guard (errno); // Lock release may smash errno - new_thr_desc->sync_->release (); - return -1; - } - auto_thread_args.release (); - -#if defined (ACE_HAS_WTHREADS) - // Have to duplicate handle if client asks for it. - // @@ How are thread handles implemented on AIX? Do they - // also need to be duplicated? - if (t_handle != 0) -# if defined (ACE_LACKS_DUPLICATEHANDLE) - *t_handle = thr_handle; -# else /* ! ACE_LACKS_DUP */ - (void) ::DuplicateHandle (::GetCurrentProcess (), - thr_handle, - ::GetCurrentProcess (), - t_handle, - 0, - TRUE, - DUPLICATE_SAME_ACCESS); -# endif /* ! ACE_LACKS_DUP */ -#else /* ! ACE_HAS_WTHREADS */ - if (t_handle != 0) - *t_handle = thr_handle; -#endif /* ! ACE_HAS_WTHREADS */ - - // append_thr also put the into Thread_Manager's - // double-linked list. Only after this point, can we manipulate - // double-linked list from a spawned thread's context. - return this->append_thr (*t_id, - thr_handle, - ACE_THR_SPAWNED, - grp_id, - task, - flags, - new_thr_desc.release ()); -} - -int -ACE_Thread_Manager::spawn (ACE_THR_FUNC func, - void *args, - long flags, - ACE_thread_t *t_id, - ACE_hthread_t *t_handle, - long priority, - int grp_id, - void *stack, - size_t stack_size, - const char** thr_name) -{ - ACE_TRACE ("ACE_Thread_Manager::spawn"); - - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - if (grp_id == -1) - grp_id = this->grp_id_++; // Increment the group id. - - if (priority != ACE_DEFAULT_THREAD_PRIORITY) - ACE_CLR_BITS (flags, THR_INHERIT_SCHED); - - if (this->spawn_i (func, - args, - flags, - t_id, - t_handle, - priority, - grp_id, - stack, - stack_size, - 0, - thr_name) == -1) - return -1; - - return grp_id; -} - -// Create N new threads running FUNC. - -int -ACE_Thread_Manager::spawn_n (size_t n, - ACE_THR_FUNC func, - void *args, - long flags, - long priority, - int grp_id, - ACE_Task_Base *task, - ACE_hthread_t thread_handles[], - void *stack[], - size_t stack_size[], - const char* thr_name[]) -{ - ACE_TRACE ("ACE_Thread_Manager::spawn_n"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - if (grp_id == -1) - grp_id = this->grp_id_++; // Increment the group id. - - for (size_t i = 0; i < n; i++) - { - // @@ What should happen if this fails?! e.g., should we try to - // cancel the other threads that we've already spawned or what? - if (this->spawn_i (func, - args, - flags, - 0, - thread_handles == 0 ? 0 : &thread_handles[i], - priority, - grp_id, - stack == 0 ? 0 : stack[i], - stack_size == 0 ? ACE_DEFAULT_THREAD_STACKSIZE : stack_size[i], - task, - thr_name == 0 ? 0 : &thr_name [i]) == -1) - return -1; - } - - return grp_id; -} - -// Create N new threads running FUNC. - -int -ACE_Thread_Manager::spawn_n (ACE_thread_t thread_ids[], - size_t n, - ACE_THR_FUNC func, - void *args, - long flags, - long priority, - int grp_id, - void *stack[], - size_t stack_size[], - ACE_hthread_t thread_handles[], - ACE_Task_Base *task, - const char* thr_name[]) -{ - ACE_TRACE ("ACE_Thread_Manager::spawn_n"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - if (grp_id == -1) - grp_id = this->grp_id_++; // Increment the group id. - - for (size_t i = 0; i < n; i++) - { - // @@ What should happen if this fails?! e.g., should we try to - // cancel the other threads that we've already spawned or what? - if (this->spawn_i (func, - args, - flags, - thread_ids == 0 ? 0 : &thread_ids[i], - thread_handles == 0 ? 0 : &thread_handles[i], - priority, - grp_id, - stack == 0 ? 0 : stack[i], - stack_size == 0 ? ACE_DEFAULT_THREAD_STACKSIZE : stack_size[i], - task, - thr_name == 0 ? 0 : &thr_name [i]) == -1) - return -1; - } - - return grp_id; -} - -// Append a thread into the pool (does not check for duplicates). -// Must be called with locks held. - -int -ACE_Thread_Manager::append_thr (ACE_thread_t t_id, - ACE_hthread_t t_handle, - ACE_UINT32 thr_state, - int grp_id, - ACE_Task_Base *task, - long flags, - ACE_Thread_Descriptor *td) -{ - ACE_TRACE ("ACE_Thread_Manager::append_thr"); - ACE_Thread_Descriptor *thr_desc = 0; - - if (td == 0) - { - ACE_NEW_RETURN (thr_desc, - ACE_Thread_Descriptor, - -1); - thr_desc->tm_ = this; - // Setup the Thread_Manager. - } - else - thr_desc = td; - - thr_desc->thr_id_ = t_id; - thr_desc->thr_handle_ = t_handle; - thr_desc->grp_id_ = grp_id; - thr_desc->task_ = task; - thr_desc->flags_ = flags; - - this->thr_list_.insert_head (thr_desc); - ACE_SET_BITS (thr_desc->thr_state_, thr_state); - thr_desc->sync_->release (); - - return 0; -} - -// Return the thread descriptor (indexed by ACE_hthread_t). - -ACE_Thread_Descriptor * -ACE_Thread_Manager::find_hthread (ACE_hthread_t h_id) -{ - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (ACE_OS::thr_cmp (iter.next ()->thr_handle_, h_id)) - { - return iter.next (); - } - } - - return 0; -} - -// Locate the index in the table associated with . Must be -// called with the lock held. - -ACE_Thread_Descriptor * -ACE_Thread_Manager::find_thread (ACE_thread_t t_id) -{ - ACE_TRACE ("ACE_Thread_Manager::find_thread"); - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (ACE_OS::thr_equal (iter.next ()->thr_id_, t_id)) - { - return iter.next (); - } - } - return 0; -} - -// Insert a thread into the pool (checks for duplicates and doesn't -// allow them to be inserted twice). - -int -ACE_Thread_Manager::insert_thr (ACE_thread_t t_id, - ACE_hthread_t t_handle, - int grp_id, - long flags) -{ - ACE_TRACE ("ACE_Thread_Manager::insert_thr"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - // Check for duplicates and bail out if we're already registered... - if (this->find_thread (t_id) != 0 ) - return -1; - - if (grp_id == -1) - grp_id = this->grp_id_++; - - if (this->append_thr (t_id, - t_handle, - ACE_THR_SPAWNED, - grp_id, - 0, - flags) == -1) - return -1; - - return grp_id; -} - -// Run the registered hooks when the thread exits. - -void -ACE_Thread_Manager::run_thread_exit_hooks (int i) -{ -#if 0 // currently unused! - ACE_TRACE ("ACE_Thread_Manager::run_thread_exit_hooks"); - - // @@ Currently, we have just one hook. This should clearly be - // generalized to support an arbitrary number of hooks. - - ACE_Thread_Descriptor *td = this->thread_desc_self (); - for (ACE_Cleanup_Info_Node *iter = td->cleanup_info_->pop_front (); - iter != 0; - iter = cleanup_info_->pop_front ()) - { - if (iter->cleanup_hook () != 0) - { - (*iter->cleanup_hook ()) (iter->object (), iter->param ()); - } - delete iter; - } - - ACE_UNUSED_ARG (i); -#else - ACE_UNUSED_ARG (i); -#endif /* 0 */ -} - -// Remove a thread from the pool. Must be called with locks held. - -void -ACE_Thread_Manager::remove_thr (ACE_Thread_Descriptor *td, - int close_handler) -{ - ACE_TRACE ("ACE_Thread_Manager::remove_thr"); - - td->tm_ = 0; - this->thr_list_.remove (td); - -#if defined (ACE_WIN32) - if (close_handler != 0) - ::CloseHandle (td->thr_handle_); -#else - ACE_UNUSED_ARG (close_handler); -#endif /* ACE_WIN32 */ - - this->thread_desc_freelist_.add (td); - -#if defined (ACE_HAS_THREADS) - // Tell all waiters when there are no more threads left in the pool. - if (this->thr_list_.size () == 0) - this->zero_cond_.broadcast (); -#endif /* ACE_HAS_THREADS */ -} - -// Repeatedly call remove_thr on all table entries until there -// is no thread left. Must be called with lock held. -void -ACE_Thread_Manager::remove_thr_all (void) -{ - ACE_Thread_Descriptor *td = 0; - - while ((td = this->thr_list_.delete_head ()) != 0) - { - this->remove_thr (td, 1); - } -} - -// ------------------------------------------------------------------ -// Factor out some common behavior to simplify the following methods. -#define ACE_THR_OP(OP,STATE) \ - int result = OP (td->thr_handle_); \ - if (result == -1) { \ - if (errno != ENOTSUP) \ - this->thr_to_be_removed_.enqueue_tail (td); \ - return -1; \ - } \ - else { \ - ACE_SET_BITS (td->thr_state_, STATE); \ - return 0; \ - } - -int -ACE_Thread_Manager::join_thr (ACE_Thread_Descriptor *td, int) -{ - ACE_TRACE ("ACE_Thread_Manager::join_thr"); - -#if defined (ACE_HAS_THREADS) && defined (ACE_LACKS_PTHREAD_JOIN) - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - if (ACE_BIT_DISABLED (td->flags_, THR_DETACHED | THR_DAEMON) - || ACE_BIT_ENABLED (td->flags_, THR_JOINABLE)) - { - if (td->terminated_) - return 0; - ACE_SET_BITS (td->thr_state_, ACE_THR_JOINING); - } - else - { - errno = EINVAL; - return -1; - } - - const ACE_thread_t waiting_id = td->thr_id_; - - while (true) - { - if (this->join_cond_.wait () == -1) - return -1; - - bool found = false; - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done () && !found; iter.advance ()) - if (ACE_OS::thr_equal (iter.next ()->thr_id_, waiting_id)) - found = true; - if (!found) - break; - } - -#else - int const result = ACE_Thread::join (td->thr_handle_); - if (result != 0) - { - // Since the thread are being joined, we should - // let it remove itself from the list. - - // this->remove_thr (td); - errno = result; - return -1; - } -#endif // ACE_HAS_THREADS && ACE_LACKS_PTHREAD_JOIN - - return 0; -} - -int -ACE_Thread_Manager::suspend_thr (ACE_Thread_Descriptor *td, int) -{ - ACE_TRACE ("ACE_Thread_Manager::suspend_thr"); - - int const result = ACE_Thread::suspend (td->thr_handle_); - if (result == -1) { - if (errno != ENOTSUP) - this->thr_to_be_removed_.enqueue_tail (td); - return -1; - } - else { - ACE_SET_BITS (td->thr_state_, ACE_THR_SUSPENDED); - return 0; - } -} - -int -ACE_Thread_Manager::resume_thr (ACE_Thread_Descriptor *td, int) -{ - ACE_TRACE ("ACE_Thread_Manager::resume_thr"); - - int const result = ACE_Thread::resume (td->thr_handle_); - if (result == -1) { - if (errno != ENOTSUP) - this->thr_to_be_removed_.enqueue_tail (td); - return -1; - } - else { - ACE_CLR_BITS (td->thr_state_, ACE_THR_SUSPENDED); - return 0; - } -} - -int -ACE_Thread_Manager::cancel_thr (ACE_Thread_Descriptor *td, int async_cancel) -{ - ACE_TRACE ("ACE_Thread_Manager::cancel_thr"); - // Must set the state first and then try to cancel the thread. - ACE_SET_BITS (td->thr_state_, ACE_THR_CANCELLED); - - if (async_cancel != 0) - // Note that this call only does something relevant if the OS - // platform supports asynchronous thread cancellation. Otherwise, - // it's a no-op. - return ACE_Thread::cancel (td->thr_id_); - - return 0; -} - -int -ACE_Thread_Manager::kill_thr (ACE_Thread_Descriptor *td, int signum) -{ - ACE_TRACE ("ACE_Thread_Manager::kill_thr"); - - ACE_thread_t tid = td->thr_id_; - - int const result = ACE_Thread::kill (tid, signum); - - if (result != 0) - { - // Only remove a thread from us when there is a "real" error. - if (errno != ENOTSUP) - this->thr_to_be_removed_.enqueue_tail (td); - - return -1; - } - - return 0; -} - -// ------------------------------------------------------------------ -// Factor out some common behavior to simplify the following methods. -#define ACE_EXECUTE_OP(OP, ARG) \ - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); \ - ACE_ASSERT (this->thr_to_be_removed_.is_empty ()); \ - ACE_FIND (this->find_thread (t_id), ptr); \ - if (ptr == 0) \ - { \ - errno = ENOENT; \ - return -1; \ - } \ - int const result = OP (ptr, ARG); \ - ACE_Errno_Guard error (errno); \ - while (! this->thr_to_be_removed_.is_empty ()) { \ - ACE_Thread_Descriptor * td = 0; \ - this->thr_to_be_removed_.dequeue_head (td); \ - this->remove_thr (td, 1); \ - } \ - return result - -// Suspend a single thread. - -int -ACE_Thread_Manager::suspend (ACE_thread_t t_id) -{ - ACE_TRACE ("ACE_Thread_Manager::suspend"); - ACE_EXECUTE_OP (this->suspend_thr, 0); -} - -// Resume a single thread. - -int -ACE_Thread_Manager::resume (ACE_thread_t t_id) -{ - ACE_TRACE ("ACE_Thread_Manager::resume"); - ACE_EXECUTE_OP (this->resume_thr, 0); -} - -// Cancel a single thread. - -int -ACE_Thread_Manager::cancel (ACE_thread_t t_id, int async_cancel) -{ - ACE_TRACE ("ACE_Thread_Manager::cancel"); - ACE_EXECUTE_OP (this->cancel_thr, async_cancel); -} - -// Send a signal to a single thread. - -int -ACE_Thread_Manager::kill (ACE_thread_t t_id, int signum) -{ - ACE_TRACE ("ACE_Thread_Manager::kill"); - ACE_EXECUTE_OP (this->kill_thr, signum); -} - -int -ACE_Thread_Manager::check_state (ACE_UINT32 state, - ACE_thread_t id, - int enable) -{ - ACE_TRACE ("ACE_Thread_Manager::check_state"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - ACE_UINT32 thr_state; - - int self_check = ACE_OS::thr_equal (id, ACE_OS::thr_self ()); - - // If we're checking the state of our thread, try to get the cached - // value out of TSS to avoid lookup. - if (self_check) - { - ACE_Thread_Descriptor *desc = ACE_LOG_MSG->thr_desc (); - if (desc == 0) - return 0; // Always return false. - thr_state = desc->thr_state_; - } - else - { - // Not calling from self, have to look it up from the list. - ACE_FIND (this->find_thread (id), ptr); - if (ptr == 0) - return 0; - thr_state = ptr->thr_state_; - } - if (enable) - return ACE_BIT_ENABLED (thr_state, state); - - return ACE_BIT_DISABLED (thr_state, state); -} - -// Test if a single thread has terminated. - -int -ACE_Thread_Manager::testterminate (ACE_thread_t t_id) -{ - ACE_TRACE ("ACE_Thread_Manager::testterminate"); - return this->check_state (ACE_THR_TERMINATED, t_id); -} - -// Test if a single thread is suspended. - -int -ACE_Thread_Manager::testsuspend (ACE_thread_t t_id) -{ - ACE_TRACE ("ACE_Thread_Manager::testsuspend"); - return this->check_state (ACE_THR_SUSPENDED, t_id); -} - -// Test if a single thread is active (i.e., resumed). - -int -ACE_Thread_Manager::testresume (ACE_thread_t t_id) -{ - ACE_TRACE ("ACE_Thread_Manager::testresume"); - return this->check_state (ACE_THR_SUSPENDED, t_id, 0); -} - -// Test if a single thread is cancelled. - -int -ACE_Thread_Manager::testcancel (ACE_thread_t t_id) -{ - ACE_TRACE ("ACE_Thread_Manager::testcancel"); - return this->check_state (ACE_THR_CANCELLED, t_id); -} - -// Thread information query functions. - -int -ACE_Thread_Manager::hthread_within (ACE_hthread_t handle) -{ - ACE_TRACE ("ACE_Thread_Manager::hthread_within"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_monx, this->lock_, -1)); - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (ACE_OS::thr_cmp(iter.next ()->thr_handle_, handle)) - { - return 1; - } - } - - return 0; -} - -int -ACE_Thread_Manager::thread_within (ACE_thread_t tid) -{ - ACE_TRACE ("ACE_Thread_Manager::thread_within"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_monx, this->lock_, -1)); - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (ACE_OS::thr_equal (iter.next ()->thr_id_, tid)) - { - return 1; - } - } - - return 0; -} - -// Get group ids for a particular thread id. - -int -ACE_Thread_Manager::get_grp (ACE_thread_t t_id, int &grp_id) -{ - ACE_TRACE ("ACE_Thread_Manager::get_grp"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - ACE_FIND (this->find_thread (t_id), ptr); - - if (ptr) - grp_id = ptr->grp_id_; - else - return -1; - return 0; -} - -// Set group ids for a particular thread id. - -int -ACE_Thread_Manager::set_grp (ACE_thread_t t_id, int grp_id) -{ - ACE_TRACE ("ACE_Thread_Manager::set_grp"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - ACE_FIND (this->find_thread (t_id), ptr); - if (ptr) - ptr->grp_id_ = grp_id; - else - return -1; - return 0; -} - -// Suspend a group of threads. - -int -ACE_Thread_Manager::apply_grp (int grp_id, - ACE_THR_MEMBER_FUNC func, - int arg) -{ - ACE_TRACE ("ACE_Thread_Manager::apply_grp"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_monx, this->lock_, -1)); - ACE_ASSERT (this->thr_to_be_removed_.is_empty ()); - - int result = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (iter.next ()->grp_id_ == grp_id) - { - if ((this->*func) (iter.next (), arg) == -1) - { - result = -1; - } - } - } - - // Must remove threads after we have traversed the thr_list_ to - // prevent clobber thr_list_'s integrity. - - if (! this->thr_to_be_removed_.is_empty ()) - { - // Save/restore errno. - ACE_Errno_Guard error (errno); - - for (ACE_Thread_Descriptor *td; - this->thr_to_be_removed_.dequeue_head (td) != -1; - ) - this->remove_thr (td, 1); - } - - return result; -} - -int -ACE_Thread_Manager::suspend_grp (int grp_id) -{ - ACE_TRACE ("ACE_Thread_Manager::suspend_grp"); - return this->apply_grp (grp_id, - ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::suspend_thr)); -} - -// Resume a group of threads. - -int -ACE_Thread_Manager::resume_grp (int grp_id) -{ - ACE_TRACE ("ACE_Thread_Manager::resume_grp"); - return this->apply_grp (grp_id, - ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::resume_thr)); -} - -// Kill a group of threads. - -int -ACE_Thread_Manager::kill_grp (int grp_id, int signum) -{ - ACE_TRACE ("ACE_Thread_Manager::kill_grp"); - return this->apply_grp (grp_id, - ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::kill_thr), signum); -} - -// Cancel a group of threads. - -int -ACE_Thread_Manager::cancel_grp (int grp_id, int async_cancel) -{ - ACE_TRACE ("ACE_Thread_Manager::cancel_grp"); - return this->apply_grp (grp_id, - ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::cancel_thr), - async_cancel); -} - -int -ACE_Thread_Manager::apply_all (ACE_THR_MEMBER_FUNC func, int arg) -{ - ACE_TRACE ("ACE_Thread_Manager::apply_all"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - ACE_ASSERT (this->thr_to_be_removed_.is_empty ()); - - int result = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if ((this->*func)(iter.next (), arg) == -1) - { - result = -1; - } - } - - // Must remove threads after we have traversed the thr_list_ to - // prevent clobber thr_list_'s integrity. - - if (! this->thr_to_be_removed_.is_empty ()) - { - // Save/restore errno. - ACE_Errno_Guard error (errno); - - for (ACE_Thread_Descriptor *td; - this->thr_to_be_removed_.dequeue_head (td) != -1; - ) - this->remove_thr (td, 1); - } - - return result; -} - -// Resume all threads that are suspended. - -int -ACE_Thread_Manager::resume_all (void) -{ - ACE_TRACE ("ACE_Thread_Manager::resume_all"); - return this->apply_all (ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::resume_thr)); -} - -int -ACE_Thread_Manager::suspend_all (void) -{ - ACE_TRACE ("ACE_Thread_Manager::suspend_all"); - return this->apply_all (ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::suspend_thr)); -} - -int -ACE_Thread_Manager::kill_all (int sig) -{ - ACE_TRACE ("ACE_Thread_Manager::kill_all"); - return this->apply_all (&ACE_Thread_Manager::kill_thr, sig); -} - -int -ACE_Thread_Manager::cancel_all (int async_cancel) -{ - ACE_TRACE ("ACE_Thread_Manager::cancel_all"); - return this->apply_all (ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::cancel_thr), - async_cancel); -} - -int -ACE_Thread_Manager::join (ACE_thread_t tid, ACE_THR_FUNC_RETURN *status) -{ - ACE_TRACE ("ACE_Thread_Manager::join"); - - bool found = false; - ACE_Thread_Descriptor_Base tdb; - - { - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - -#if !defined (ACE_HAS_VXTHREADS) - for (ACE_Double_Linked_List_Iterator biter (this->terminated_thr_list_); - !biter.done (); - biter.advance ()) - { - if (ACE_OS::thr_equal (biter.next ()->thr_id_, tid)) - { - ACE_Thread_Descriptor_Base *tdbl = biter.advance_and_remove (false); -#ifndef ACE_LACKS_PTHREAD_JOIN - if (ACE_Thread::join (tdbl->thr_handle_, status) == -1) - { - return -1; - } -#endif - delete tdbl; - - // return immediately if we've found the thread we want to join. - return 0; - } - } -#endif /* !ACE_HAS_VXTHREADS */ - - typedef ACE_Double_Linked_List_Iterator iter_t; - for (iter_t iter (this->thr_list_); !iter.done (); iter.advance ()) - { - // If threads are created as THR_DETACHED or THR_DAEMON, we - // can't help much. - if (ACE_OS::thr_equal (iter.next ()->thr_id_,tid) && - (ACE_BIT_DISABLED (iter.next ()->flags_, THR_DETACHED | THR_DAEMON) - || ACE_BIT_ENABLED (iter.next ()->flags_, THR_JOINABLE))) - { - tdb = *iter.next (); - ACE_SET_BITS (iter.next ()->thr_state_, ACE_THR_JOINING); - found = true; - break; - } - } - - if (!found) - return -1; - // Didn't find the thread we want or the thread is not joinable. - -#if defined (ACE_HAS_THREADS) && defined (ACE_LACKS_PTHREAD_JOIN) - ACE_UNUSED_ARG (status); // not currently supported without pthread_join - - while (found) - { - if (this->join_cond_.wait () == -1) - return -1; - - found = false; - for (iter_t iter (this->thr_list_); !iter.done () && !found; iter.advance ()) - if (ACE_OS::thr_equal (iter.next ()->thr_id_, tid) && - (ACE_BIT_DISABLED (iter.next ()->flags_, THR_DETACHED | THR_DAEMON) - || ACE_BIT_ENABLED (iter.next ()->flags_, THR_JOINABLE))) - found = true; - } - -#endif // ACE_HAS_THREADS && ACE_LACKS_PTHREAD_JOIN - - } - -#ifndef ACE_LACKS_PTHREAD_JOIN - if (ACE_Thread::join (tdb.thr_handle_, status) == -1) - return -1; -#endif - - return 0; -} - -// Wait for group of threads - -int -ACE_Thread_Manager::wait_grp (int grp_id) -{ - ACE_TRACE ("ACE_Thread_Manager::wait_grp"); - - int copy_count = 0; - ACE_Thread_Descriptor_Base *copy_table = 0; - - // We have to make sure that while we wait for these threads to - // exit, we do not have the lock. Therefore we make a copy of all - // interesting entries and let go of the lock. - { - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - -#if !defined (ACE_HAS_VXTHREADS) - ACE_NEW_RETURN (copy_table, - ACE_Thread_Descriptor_Base [this->thr_list_.size () - + this->terminated_thr_list_.size ()], - -1); -#else - ACE_NEW_RETURN (copy_table, - ACE_Thread_Descriptor_Base [this->thr_list_.size ()], - -1); -#endif /* !ACE_HAS_VXTHREADS */ - - typedef ACE_Double_Linked_List_Iterator iter_t; - for (iter_t iter (this->thr_list_); !iter.done (); iter.advance ()) - { - // If threads are created as THR_DETACHED or THR_DAEMON, we - // can't help much. - if (iter.next ()->grp_id_ == grp_id && - (ACE_BIT_DISABLED (iter.next ()->flags_, THR_DETACHED | THR_DAEMON) - || ACE_BIT_ENABLED (iter.next ()->flags_, THR_JOINABLE))) - { - ACE_SET_BITS (iter.next ()->thr_state_, ACE_THR_JOINING); - copy_table[copy_count++] = *iter.next (); - } - } - -#if !defined (ACE_HAS_VXTHREADS) - for (ACE_Double_Linked_List_Iterator biter (this->terminated_thr_list_); - !biter.done (); - biter.advance ()) - { - // If threads are created as THR_DETACHED or THR_DAEMON, we - // can't help much. - if (biter.next ()->grp_id_ == grp_id) - { - ACE_Thread_Descriptor_Base *tdb = biter.advance_and_remove (false); - copy_table[copy_count++] = *tdb; - delete tdb; - } - } -#endif /* !ACE_HAS_VXTHREADS */ - -#if defined (ACE_HAS_THREADS) && defined (ACE_LACKS_PTHREAD_JOIN) - - while (copy_count) - { - if (this->join_cond_.wait () == -1) - { - delete[] copy_table; - return -1; - } - - copy_count = 0; - for (iter_t iter (this->thr_list_); !iter.done () && !copy_count; iter.advance ()) - if (iter.next ()->grp_id_ == grp_id && - ACE_BIT_ENABLED (iter.next ()->thr_state_, ACE_THR_JOINING) && - (ACE_BIT_DISABLED (iter.next ()->flags_, - THR_DETACHED | THR_DAEMON) - || ACE_BIT_ENABLED (iter.next ()->flags_, THR_JOINABLE))) - ++copy_count; - } - -#endif // ACE_HAS_THREADS && ACE_LACKS_PTHREAD_JOIN - } - - // Now actually join() with all the threads in this group. - int result = 0; - - for (int i = 0; - i < copy_count && result != -1; - i++) - { - if (ACE_Thread::join (copy_table[i].thr_handle_) == -1) - result = -1; - } - - delete [] copy_table; - - return result; -} - -// Must be called when thread goes out of scope to clean up its table -// slot. - -ACE_THR_FUNC_RETURN -ACE_Thread_Manager::exit (ACE_THR_FUNC_RETURN status, bool do_thread_exit) -{ - ACE_TRACE ("ACE_Thread_Manager::exit"); -#if defined (ACE_WIN32) - // Remove detached thread handle. - - if (do_thread_exit) - { -#if 0 - // @@ This callback is now taken care of by TSS_Cleanup. Do we - // need it anymore? - - // On Win32, if we really wants to exit from a thread, we must - // first clean up the thread specific storage. By doing so, - // ACE_Thread_Manager::exit will be called again with - // do_thr_exit = 0 and cleaning up the ACE_Cleanup_Info (but not - // exiting the thread.) After the following call returns, we - // are safe to exit this thread. - delete ACE_Thread_Exit::instance (); -#endif /* 0 */ - ACE_Thread::exit (status); - } -#endif /* ACE_WIN32 */ - - // Just hold onto the guard while finding this thread's id and - { - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, 0)); - - // Find the thread id, but don't use the cache. It might have been - // deleted already. - ACE_thread_t const id = ACE_OS::thr_self (); - ACE_Thread_Descriptor* td = this->find_thread (id); - if (td != 0) - { - // @@ We call Thread_Descriptor terminate this realize the cleanup - // process itself. - td->terminate(); - -#if defined (ACE_HAS_THREADS) && defined (ACE_LACKS_PTHREAD_JOIN) - this->join_cond_.broadcast (); -#endif - } - } - - if (do_thread_exit) - { - ACE_Thread::exit (status); - // On reasonable systems should not return. - // However, due to horrible semantics with Win32 thread-specific - // storage this call can return (don't ask...). - } - - return 0; -} - -// Wait for all the threads to exit. - -int -ACE_Thread_Manager::wait (const ACE_Time_Value *timeout, - bool abandon_detached_threads, - bool use_absolute_time) -{ - ACE_TRACE ("ACE_Thread_Manager::wait"); - - ACE_Auto_Ptr local_timeout; - // Check to see if we're using absolute time or not. - if (use_absolute_time == false && timeout != 0) - { - // create time value duplicate (preserves time policy) - local_timeout.reset (timeout->duplicate ()); - // convert time value to absolute time - (*local_timeout) = local_timeout->to_absolute_time (); - // replace original time by abs time duplicate - timeout = local_timeout.get (); - } - -#if !defined (ACE_HAS_VXTHREADS) - ACE_Double_Linked_List term_thr_list_copy; -#endif /* ACE_HAS_VXTHREADS */ - -#if defined (ACE_HAS_THREADS) - { - // Just hold onto the guard while waiting. - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - if (ACE_Object_Manager::shutting_down () != 1) - { - // Program is not shutting down. Perform a normal wait on threads. - if (abandon_detached_threads != 0) - { - ACE_ASSERT (this->thr_to_be_removed_.is_empty ()); - for (ACE_Double_Linked_List_Iterator - iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (ACE_BIT_ENABLED (iter.next ()->flags_, - THR_DETACHED | THR_DAEMON) - && ACE_BIT_DISABLED (iter.next ()->flags_, THR_JOINABLE)) - { - this->thr_to_be_removed_.enqueue_tail (iter.next ()); - ACE_SET_BITS (iter.next ()->thr_state_, ACE_THR_JOINING); - } - } - - if (! this->thr_to_be_removed_.is_empty ()) - { - ACE_Thread_Descriptor *td = 0; - while (this->thr_to_be_removed_.dequeue_head (td) != -1) - this->remove_thr (td, 1); - } - } - - while (this->thr_list_.size () > 0) - if (this->zero_cond_.wait (timeout) == -1) - return -1; - } - else - // Program is shutting down, no chance to wait on threads. - // Therefore, we'll just remove threads from the list. - this->remove_thr_all (); - -#if !defined (ACE_HAS_VXTHREADS) - ACE_Thread_Descriptor_Base* item = 0; - while ((item = this->terminated_thr_list_.delete_head ()) != 0) - { - term_thr_list_copy.insert_tail (item); - } -#endif /* ACE_HAS_VXTHREADS */ - // Release the guard, giving other threads a chance to run. - } - -#if !defined (ACE_HAS_VXTHREADS) - // @@ VxWorks doesn't support thr_join (yet.) We are working - // on our implementation. Chorus'es thr_join seems broken. - ACE_Thread_Descriptor_Base *item = 0; - - while ((item = term_thr_list_copy.delete_head ()) != 0) - { -#ifndef ACE_LACKS_PTHREAD_JOIN - if (ACE_BIT_DISABLED (item->flags_, THR_DETACHED | THR_DAEMON) - || ACE_BIT_ENABLED (item->flags_, THR_JOINABLE)) - // Detached handles shouldn't reached here. - (void) ACE_Thread::join (item->thr_handle_); -#endif - delete item; - } - -#endif /* !ACE_HAS_VXTHREADS */ -#else - ACE_UNUSED_ARG (timeout); - ACE_UNUSED_ARG (abandon_detached_threads); -#endif /* ACE_HAS_THREADS */ - - return 0; -} - -int -ACE_Thread_Manager::apply_task (ACE_Task_Base *task, - ACE_THR_MEMBER_FUNC func, - int arg) -{ - ACE_TRACE ("ACE_Thread_Manager::apply_task"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - ACE_ASSERT (this->thr_to_be_removed_.is_empty ()); - - int result = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - if (iter.next ()->task_ == task - && (this->*func) (iter.next (), arg) == -1) - result = -1; - - // Must remove threads after we have traversed the thr_list_ to - // prevent clobber thr_list_'s integrity. - - if (! this->thr_to_be_removed_.is_empty ()) - { - // Save/restore errno. - ACE_Errno_Guard error (errno); - - for (ACE_Thread_Descriptor *td = 0; - this->thr_to_be_removed_.dequeue_head (td) != -1; - ) - this->remove_thr (td, 1); - } - - return result; -} - -// Wait for all threads to exit a task. - -int -ACE_Thread_Manager::wait_task (ACE_Task_Base *task) -{ - int copy_count = 0; - ACE_Thread_Descriptor_Base *copy_table = 0; - - // We have to make sure that while we wait for these threads to - // exit, we do not have the lock. Therefore we make a copy of all - // interesting entries and let go of the lock. - { - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - -#if !defined (ACE_HAS_VXTHREADS) - ACE_NEW_RETURN (copy_table, - ACE_Thread_Descriptor_Base [this->thr_list_.size () - + this->terminated_thr_list_.size ()], - -1); -#else - ACE_NEW_RETURN (copy_table, - ACE_Thread_Descriptor_Base [this->thr_list_.size ()], - -1); -#endif /* !ACE_HAS_VXTHREADS */ - - typedef ACE_Double_Linked_List_Iterator iter_t; - for (iter_t iter (this->thr_list_); !iter.done (); iter.advance ()) - { - // If threads are created as THR_DETACHED or THR_DAEMON, we - // can't wait on them here. - if (iter.next ()->task_ == task && - (ACE_BIT_DISABLED (iter.next ()->flags_, - THR_DETACHED | THR_DAEMON) - || ACE_BIT_ENABLED (iter.next ()->flags_, - THR_JOINABLE))) - { -# ifdef ACE_LACKS_PTHREAD_JOIN - if (ACE_OS::thr_equal (iter.next ()->thr_id_, ACE_OS::thr_self ())) - { - errno = EDEADLK; - delete[] copy_table; - return -1; - } -# endif - ACE_SET_BITS (iter.next ()->thr_state_, - ACE_THR_JOINING); - copy_table[copy_count++] = *iter.next (); - } - } - -#if !defined (ACE_HAS_VXTHREADS) - for (ACE_Double_Linked_List_Iterator titer (this->terminated_thr_list_); - !titer.done (); - titer.advance ()) - { - // If threads are created as THR_DETACHED or THR_DAEMON, we can't help much here. - if (titer.next ()->task_ == task) - { - ACE_Thread_Descriptor_Base *tdb = titer.advance_and_remove (false); -# ifndef ACE_LACKS_PTHREAD_JOIN - copy_table[copy_count++] = *tdb; -# endif - delete tdb; - } - } -#endif /* !ACE_HAS_VXTHREADS */ - -#if defined (ACE_HAS_THREADS) && defined (ACE_LACKS_PTHREAD_JOIN) - - while (copy_count) - { - if (this->join_cond_.wait () == -1) - { - delete[] copy_table; - return -1; - } - - copy_count = 0; - for (iter_t iter (this->thr_list_); !iter.done () && !copy_count; iter.advance ()) - if (iter.next ()->task_ == task && - ACE_BIT_ENABLED (iter.next ()->thr_state_, ACE_THR_JOINING) && - (ACE_BIT_DISABLED (iter.next ()->flags_, - THR_DETACHED | THR_DAEMON) - || ACE_BIT_ENABLED (iter.next ()->flags_, THR_JOINABLE))) - ++copy_count; - } - -#endif // ACE_HAS_THREADS && ACE_LACKS_PTHREAD_JOIN - } - - // Now to do the actual work - int result = 0; - - for (int i = 0; - i < copy_count && result != -1; - i++) - { - if (ACE_Thread::join (copy_table[i].thr_handle_) == -1) - result = -1; - } - - delete [] copy_table; - - return result; -} - -// Suspend a task - -int -ACE_Thread_Manager::suspend_task (ACE_Task_Base *task) -{ - ACE_TRACE ("ACE_Thread_Manager::suspend_task"); - return this->apply_task (task, - ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::suspend_thr)); -} - -// Resume a task. -int -ACE_Thread_Manager::resume_task (ACE_Task_Base *task) -{ - ACE_TRACE ("ACE_Thread_Manager::resume_task"); - return this->apply_task (task, - ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::resume_thr)); -} - -// Kill a task. - -int -ACE_Thread_Manager::kill_task (ACE_Task_Base *task, int /* signum */) -{ - ACE_TRACE ("ACE_Thread_Manager::kill_task"); - return this->apply_task (task, - ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::kill_thr)); -} - -// Cancel a task. -int -ACE_Thread_Manager::cancel_task (ACE_Task_Base *task, - int async_cancel) -{ - ACE_TRACE ("ACE_Thread_Manager::cancel_task"); - return this->apply_task (task, - ACE_THR_MEMBER_FUNC (&ACE_Thread_Manager::cancel_thr), - async_cancel); -} - -// Locate the index in the table associated with from the -// beginning of the table up to an index. Must be called with the -// lock held. - -ACE_Thread_Descriptor * -ACE_Thread_Manager::find_task (ACE_Task_Base *task, size_t slot) -{ - ACE_TRACE ("ACE_Thread_Manager::find_task"); - - size_t i = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (i >= slot) - break; - - if (task == iter.next ()->task_) - return iter.next (); - - ++i; - } - - return 0; -} - -// Returns the number of ACE_Task in a group. - -int -ACE_Thread_Manager::num_tasks_in_group (int grp_id) -{ - ACE_TRACE ("ACE_Thread_Manager::num_tasks_in_group"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - int tasks_count = 0; - size_t i = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (iter.next ()->grp_id_ == grp_id - && this->find_task (iter.next ()->task_, i) == 0 - && iter.next ()->task_ != 0) - { - ++tasks_count; - } - - ++i; - } - return tasks_count; -} - -// Returns the number of threads in an ACE_Task. - -int -ACE_Thread_Manager::num_threads_in_task (ACE_Task_Base *task) -{ - ACE_TRACE ("ACE_Thread_Manager::num_threads_in_task"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - int threads_count = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (iter.next ()->task_ == task) - { - ++threads_count; - } - } - - return threads_count; -} - -// Returns in task_list a list of ACE_Tasks registered with ACE_Thread_Manager. - -ssize_t -ACE_Thread_Manager::task_all_list (ACE_Task_Base *task_list[], - size_t n) -{ - ACE_TRACE ("ACE_Thread_Manager::task_all_list"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - size_t task_list_count = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (task_list_count >= n) - { - break; - } - - ACE_Task_Base *task_p = iter.next ()->task_; - - if (0 != task_p) - { - // This thread has a task pointer; see if it's already in the - // list. Don't add duplicates. - size_t i = 0; - - for (; i < task_list_count; ++i) - { - if (task_list[i] == task_p) - { - break; - } - } - - if (i == task_list_count) // No match - add this one - { - task_list[task_list_count++] = task_p; - } - } - } - - return ACE_Utils::truncate_cast (task_list_count); -} - -// Returns in thread_list a list of all thread ids - -ssize_t -ACE_Thread_Manager::thread_all_list (ACE_thread_t thread_list[], - size_t n) -{ - ACE_TRACE ("ACE_Thread_Manager::thread_all_list"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - size_t thread_count = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (thread_count >= n) - { - break; - } - - thread_list[thread_count] = iter.next ()->thr_id_; - ++thread_count; - } - - return ACE_Utils::truncate_cast (thread_count); -} - - -int -ACE_Thread_Manager::thr_state (ACE_thread_t id, - ACE_UINT32& state) -{ - ACE_TRACE ("ACE_Thread_Manager::thr_state"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - int const self_check = ACE_OS::thr_equal (id, ACE_OS::thr_self ()); - - // If we're checking the state of our thread, try to get the cached - // value out of TSS to avoid lookup. - if (self_check) - { - ACE_Thread_Descriptor *desc = ACE_LOG_MSG->thr_desc (); - - if (desc == 0) - { - return 0; // Always return false. - } - - state = desc->thr_state_; - } - else - { - // Not calling from self, have to look it up from the list. - ACE_FIND (this->find_thread (id), ptr); - - if (ptr == 0) - { - return 0; - } - - state = ptr->thr_state_; - } - - return 1; -} - -// Returns in task_list a list of ACE_Tasks in a group. - -ssize_t -ACE_Thread_Manager::task_list (int grp_id, - ACE_Task_Base *task_list[], - size_t n) -{ - ACE_TRACE ("ACE_Thread_Manager::task_list"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - ACE_Task_Base **task_list_iterator = task_list; - size_t task_list_count = 0; - size_t i = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (task_list_count >= n) - { - break; - } - - if (iter.next ()->grp_id_ == grp_id - && this->find_task (iter.next ()->task_, i) == 0) - { - task_list_iterator[task_list_count] = iter.next ()->task_; - ++task_list_count; - } - - ++i; - } - - return ACE_Utils::truncate_cast (task_list_count); -} - -// Returns in thread_list a list of thread ids in an ACE_Task. - -ssize_t -ACE_Thread_Manager::thread_list (ACE_Task_Base *task, - ACE_thread_t thread_list[], - size_t n) -{ - ACE_TRACE ("ACE_Thread_Manager::thread_list"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - size_t thread_count = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (thread_count >= n) - { - break; - } - - if (iter.next ()->task_ == task) - { - thread_list[thread_count] = iter.next ()->thr_id_; - ++thread_count; - } - } - - return ACE_Utils::truncate_cast (thread_count); -} - -// Returns in thread_list a list of thread handles in an ACE_Task. - -ssize_t -ACE_Thread_Manager::hthread_list (ACE_Task_Base *task, - ACE_hthread_t hthread_list[], - size_t n) -{ - ACE_TRACE ("ACE_Thread_Manager::hthread_list"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - size_t hthread_count = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (hthread_count >= n) - { - break; - } - - if (iter.next ()->task_ == task) - { - hthread_list[hthread_count] = iter.next ()->thr_handle_; - ++hthread_count; - } - } - - return ACE_Utils::truncate_cast (hthread_count); -} - -ssize_t -ACE_Thread_Manager::thread_grp_list (int grp_id, - ACE_thread_t thread_list[], - size_t n) -{ - ACE_TRACE ("ACE_Thread_Manager::thread_grp_list"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - size_t thread_count = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (thread_count >= n) - { - break; - } - - if (iter.next ()->grp_id_ == grp_id) - { - thread_list[thread_count] = iter.next ()->thr_id_; - thread_count++; - } - } - - return ACE_Utils::truncate_cast (thread_count); -} - -// Returns in thread_list a list of thread handles in an ACE_Task. - -ssize_t -ACE_Thread_Manager::hthread_grp_list (int grp_id, - ACE_hthread_t hthread_list[], - size_t n) -{ - ACE_TRACE ("ACE_Thread_Manager::hthread_grp_list"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - size_t hthread_count = 0; - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (hthread_count >= n) - { - break; - } - - if (iter.next ()->grp_id_ == grp_id) - { - hthread_list[hthread_count] = iter.next ()->thr_handle_; - hthread_count++; - } - } - - return ACE_Utils::truncate_cast (hthread_count); -} - -int -ACE_Thread_Manager::set_grp (ACE_Task_Base *task, int grp_id) -{ - ACE_TRACE ("ACE_Thread_Manager::set_grp"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - for (ACE_Double_Linked_List_Iterator iter (this->thr_list_); - !iter.done (); - iter.advance ()) - { - if (iter.next ()->task_ == task) - { - iter.next ()->grp_id_ = grp_id; - } - } - - return 0; -} - -int -ACE_Thread_Manager::get_grp (ACE_Task_Base *task, int &grp_id) -{ - ACE_TRACE ("ACE_Thread_Manager::get_grp"); - ACE_MT (ACE_GUARD_RETURN (ACE_Thread_Mutex, ace_mon, this->lock_, -1)); - - ACE_FIND (this->find_task (task), ptr); - grp_id = ptr->grp_id_; - return 0; -} - -ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Descriptor_Base); - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Thread_Manager.h b/deps/acelite/ace/Thread_Manager.h deleted file mode 100644 index c169d0e15..000000000 --- a/deps/acelite/ace/Thread_Manager.h +++ /dev/null @@ -1,1279 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Thread_Manager.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_THREAD_MANAGER_H -#define ACE_THREAD_MANAGER_H -#include /**/ "ace/pre.h" - -#include "ace/Thread.h" -#include "ace/Thread_Adapter.h" -#include "ace/Thread_Exit.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Condition_Thread_Mutex.h" -#include "ace/Unbounded_Queue.h" -#include "ace/Containers.h" -#include "ace/Free_List.h" -#include "ace/Singleton.h" -#include "ace/Log_Category.h" -#include "ace/Synch_Traits.h" -#include "ace/Basic_Types.h" - -// The following macros control how a Thread Manager manages a pool of -// Thread_Descriptor. Currently, the default behavior is not to -// preallocate any thread descriptor and never (well, almost never) -// free up any thread descriptor until the Thread Manager gets -// destructed. Which means, once your system is stable, you rarely -// need to pay the price of memory allocation. On a deterministic -// system, which means, the number of threads spawned can be -// determined before hand, you can either redefine the memory pool -// size macros to suit your need or constructed the Thread_Manager -// accordingly. That way, you don't pay the price of memory -// allocation when the system is really doing its job. OTOH, on -// system with resources constraint, you may want to lower the size of -// ACE_DEFAULT_THREAD_MANAGER_HWM to avoid unused memory hanging -// around. - -#if !defined (ACE_DEFAULT_THREAD_MANAGER_PREALLOC) -# define ACE_DEFAULT_THREAD_MANAGER_PREALLOC 0 -#endif /* ACE_DEFAULT_THREAD_MANAGER_PREALLOC */ - -#if !defined (ACE_DEFAULT_THREAD_MANAGER_LWM) -# define ACE_DEFAULT_THREAD_MANAGER_LWM 1 -#endif /* ACE_DEFAULT_THREAD_MANAGER_LWM */ - -#if !defined (ACE_DEFAULT_THREAD_MANAGER_INC) -# define ACE_DEFAULT_THREAD_MANAGER_INC 1 -#endif /* ACE_DEFAULT_THREAD_MANAGER_INC */ - -#if !defined (ACE_DEFAULT_THREAD_MANAGER_HWM) -# define ACE_DEFAULT_THREAD_MANAGER_HWM ACE_DEFAULT_FREE_LIST_HWM -// this is a big number -#endif /* ACE_DEFAULT_THREAD_MANAGER_HWM */ - -// This is the synchronization mechanism used to prevent a thread -// descriptor gets removed from the Thread_Manager before it gets -// stash into it. If you want to disable this feature (and risk of -// corrupting the freelist,) you define the lock as ACE_Null_Mutex. -// Usually, if you can be sure that your threads will run for an -// extended period of time, you can safely disable the lock. - -#if !defined (ACE_DEFAULT_THREAD_MANAGER_LOCK) -# define ACE_DEFAULT_THREAD_MANAGER_LOCK ACE_SYNCH_MUTEX -#endif /* ACE_DEFAULT_THREAD_MANAGER_LOCK */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -// Forward declarations. -class ACE_Task_Base; -class ACE_Thread_Manager; -class ACE_Thread_Descriptor; - -/** - * @class ACE_At_Thread_Exit - * - * @brief Contains a method to be applied when a thread is terminated. - */ -class ACE_Export ACE_At_Thread_Exit -{ - friend class ACE_Thread_Descriptor; - friend class ACE_Thread_Manager; -public: - /// Default constructor - ACE_At_Thread_Exit (void); - - /// The destructor - virtual ~ACE_At_Thread_Exit (void); - - /// At_Thread_Exit has the ownership? - bool is_owner (void) const; - - /// Set the ownership of the At_Thread_Exit. - bool is_owner (bool owner); - - /// This At_Thread_Exit was applied? - bool was_applied (void) const; - - /// Set applied state of At_Thread_Exit. - bool was_applied (bool applied); - -protected: - /// The next At_Thread_Exit hook in the list. - ACE_At_Thread_Exit *next_; - - /// Do the apply if necessary - void do_apply (void); - - /// The apply method. - virtual void apply (void) = 0; - - /// The Thread_Descriptor where this at is registered. - ACE_Thread_Descriptor* td_; - - /// The at was applied? - bool was_applied_; - - /// The at has the ownership of this? - bool is_owner_; -}; - -class ACE_Export ACE_At_Thread_Exit_Func : public ACE_At_Thread_Exit -{ -public: - /// Constructor - ACE_At_Thread_Exit_Func (void *object, - ACE_CLEANUP_FUNC func, - void *param = 0); - - virtual ~ACE_At_Thread_Exit_Func (void); - - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// The object to be cleanup - void *object_; - - /// The cleanup func - ACE_CLEANUP_FUNC func_; - - /// A param if required - void *param_; - - /// The apply method - void apply (void); -}; - -/** - * @class ACE_Thread_Descriptor_Base - * - * @brief Basic information for thread descriptors. These information - * gets extracted out because we need it after a thread is - * terminated. - * - * @internal - */ -class ACE_Export ACE_Thread_Descriptor_Base : public ACE_OS_Thread_Descriptor -{ - - friend class ACE_Thread_Manager; - friend class ACE_Double_Linked_List; - friend class ACE_Double_Linked_List_Iterator_Base; - friend class ACE_Double_Linked_List_Iterator; - friend class ACE_Double_Linked_List; - friend class ACE_Double_Linked_List_Iterator_Base; - friend class ACE_Double_Linked_List_Iterator; -public: - ACE_Thread_Descriptor_Base (void); - virtual ~ACE_Thread_Descriptor_Base (void); - - // = We need the following operators to make Borland happy. - - /// Equality operator. - bool operator== (const ACE_Thread_Descriptor_Base &rhs) const; - - /// Inequality operator. - bool operator!= (const ACE_Thread_Descriptor_Base &rhs) const; - - /// Group ID. - int grp_id (void) const; - - /// Current state of the thread. - ACE_UINT32 state (void) const; - - /// Return the pointer to an ACE_Task_Base or NULL if there's no - /// ACE_Task_Base associated with this thread.; - ACE_Task_Base *task (void) const; - - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Reset this base thread descriptor. - void reset (void); - - /// Unique thread ID. - ACE_thread_t thr_id_; - - /// Unique handle to thread (used by Win32 and AIX). - ACE_hthread_t thr_handle_; - - /// Group ID. - int grp_id_; - - /// Current state of the thread. - ACE_UINT32 thr_state_; - - /// Pointer to an ACE_Task_Base or NULL if there's no - /// ACE_Task_Base. - ACE_Task_Base *task_; - - /// We need these pointers to maintain the double-linked list in a - /// thread managers. - ACE_Thread_Descriptor_Base *next_; - ACE_Thread_Descriptor_Base *prev_; -}; - -/** - * @class ACE_Thread_Descriptor - * - * @brief Information for controlling threads that run under the control - * of the Thread_Manager. - */ -class ACE_Export ACE_Thread_Descriptor : public ACE_Thread_Descriptor_Base -{ - friend class ACE_At_Thread_Exit; - friend class ACE_Thread_Manager; - friend class ACE_Double_Linked_List; - friend class ACE_Double_Linked_List_Iterator; -public: - ACE_Thread_Descriptor (void); - - // = Accessor methods. - /// Unique thread id. - ACE_thread_t self (void) const; - - /// Unique handle to thread (used by Win32 and AIX). - void self (ACE_hthread_t &); - - /// Dump the state of an object. - void dump (void) const; - - /** - * This cleanup function must be called only for ACE_TSS_cleanup. - * The ACE_TSS_cleanup delegate Log_Msg instance destruction when - * Log_Msg cleanup is called before terminate. - */ - void log_msg_cleanup(ACE_Log_Msg* log_msg); - - /** - * Register an At_Thread_Exit hook and the ownership is acquire by - * Thread_Descriptor, this is the usual case when the AT is dynamically - * allocated. - */ - int at_exit (ACE_At_Thread_Exit* cleanup); - - /// Register an At_Thread_Exit hook and the ownership is retained for the - /// caller. Normally used when the at_exit hook is created in stack. - int at_exit (ACE_At_Thread_Exit& cleanup); - - /** - * Register an object (or array) for cleanup at thread termination. - * "cleanup_hook" points to a (global, or static member) function - * that is called for the object or array when it to be destroyed. - * It may perform any necessary cleanup specific for that object or - * its class. "param" is passed as the second parameter to the - * "cleanup_hook" function; the first parameter is the object (or - * array) to be destroyed. Returns 0 on success, non-zero on - * failure: -1 if virtual memory is exhausted or 1 if the object (or - * array) had already been registered. - */ - int at_exit (void *object, - ACE_CLEANUP_FUNC cleanup_hook, - void *param); - - /// Do nothing destructor to keep some compilers happy - ~ACE_Thread_Descriptor (void); - - /** - * Do nothing but to acquire the thread descriptor's lock and - * release. This will first check if the thread is registered or - * not. If it is already registered, there's no need to reacquire - * the lock again. This is used mainly to get newly spawned thread - * in synch with thread manager and prevent it from accessing its - * thread descriptor before it gets fully built. This function is - * only called from ACE_Log_Msg::thr_desc. - */ - void acquire_release (void); - void acquire (void); - void release (void); - - /** - * Set/get the @c next_ pointer. These are required by the - * ACE_Free_List. - */ - void set_next (ACE_Thread_Descriptor *td); - ACE_Thread_Descriptor *get_next (void) const; - -protected: - /// Run the AT_Thread_Exit hooks. - void do_at_exit (void); - - /// Terminate realize the cleanup process to thread termination - void terminate (void); - -private: - /// Reset this thread descriptor. - void reset (ACE_Thread_Manager *tm); - - /// Pop an At_Thread_Exit from at thread termination list, apply the at - /// if apply is true. - void at_pop (int apply = 1); - - /// Push an At_Thread_Exit to at thread termination list and set the - /// ownership of at. - void at_push (ACE_At_Thread_Exit* cleanup, - bool is_owner = false); - -private: - /// Thread_Descriptor is the ownership of ACE_Log_Msg if log_msg_!=0 - /// This can occur because ACE_TSS_cleanup was executed before terminate. - ACE_Log_Msg *log_msg_; - - /// The AT_Thread_Exit list - ACE_At_Thread_Exit *at_exit_list_; - -#if 0 -/// Currently not used - /** - * Stores the cleanup info for a thread. - * @note This should be generalized to be a stack of ACE_Cleanup_Info's. - */ - ACE_Cleanup_Info_Node_List cleanup_info_; -#endif - - /// Pointer to an ACE_Thread_Manager or NULL if there's no - /// ACE_Thread_Manager - ACE_Thread_Manager* tm_; - - /// Registration lock to prevent premature removal of thread descriptor. - ACE_DEFAULT_THREAD_MANAGER_LOCK *sync_; - - /// Keep track of termination status. - bool terminated_; -}; - -// Forward declaration. -class ACE_Thread_Control; - -// This typedef should be (and used to be) inside the -// ACE_Thread_Manager declaration. But, it caused compilation -// problems on g++/VxWorks/i960 with -g. Note that -// ACE_Thread_Manager::THR_FUNC is only used internally in -// ACE_Thread_Manager, so it's not useful for anyone else. -// It also caused problems on IRIX5 with g++. -#if defined (__GNUG__) -typedef int (ACE_Thread_Manager::*ACE_THR_MEMBER_FUNC)(ACE_Thread_Descriptor *, int); -#endif /* __GNUG__ */ - -/** - * @class ACE_Thread_Manager - * - * @brief Manages a pool of threads. - * - * This class allows operations on groups of threads atomically. - * The default behavior of thread manager is to wait on - * all threads under it's management when it gets destructed. - * Therefore, remember to remove a thread from thread manager if - * you don't want it to wait for the thread. There are also - * functions to disable this default wait-on-exit behavior. - * However, if your program depends on turning this off to run - * correctly, you are probably doing something wrong. Rule of - * thumb, use ACE_Thread to manage your daemon threads. - * Notice that if there're threads which live beyond the scope of - * main(), you are sure to have resource leaks in your program. - * Remember to wait on threads before exiting your main program if that - * could happen in your programs. - */ -class ACE_Export ACE_Thread_Manager -{ -public: - friend class ACE_Thread_Control; - - // Allow ACE_Thread_Exit to register the global TSS instance object. - friend class ACE_Thread_Exit; - friend class ACE_Thread_Descriptor; - -#if !defined (__GNUG__) - typedef int (ACE_Thread_Manager::*ACE_THR_MEMBER_FUNC)(ACE_Thread_Descriptor *, int); -#endif /* !__GNUG__ */ - - /// These are the various states a thread managed by the - /// ACE_Thread_Manager can be in. - enum - { - /// Uninitialized. - ACE_THR_IDLE = 0x00000000, - - /// Created but not yet running. - ACE_THR_SPAWNED = 0x00000001, - - /// Thread is active (naturally, we don't know if it's actually - /// *running* because we aren't the scheduler...). - ACE_THR_RUNNING = 0x00000002, - - /// Thread is suspended. - ACE_THR_SUSPENDED = 0x00000004, - - /// Thread has been cancelled (which is an indiction that it needs to - /// terminate...). - ACE_THR_CANCELLED = 0x00000008, - - /// Thread has shutdown, but the slot in the thread manager hasn't - /// been reclaimed yet. - ACE_THR_TERMINATED = 0x00000010, - - /// Join operation has been invoked on the thread by thread manager. - ACE_THR_JOINING = 0x10000000 - }; - - /** - * @brief Initialization and termination methods. - * - * Internally, ACE_Thread_Manager keeps a freelist for caching - * resources it uses to keep track of managed threads (not the - * threads themselves.) @a prealloc, @a lwm, @a inc, @hwm - * determine the initial size, the low water mark, increment step, - * and high water mark of the freelist. - * - * @sa ACE_Free_List - */ - ACE_Thread_Manager (size_t preaolloc = ACE_DEFAULT_THREAD_MANAGER_PREALLOC, - size_t lwm = ACE_DEFAULT_THREAD_MANAGER_LWM, - size_t inc = ACE_DEFAULT_THREAD_MANAGER_INC, - size_t hwm = ACE_DEFAULT_THREAD_MANAGER_HWM); - ACE_Thread_Manager (const ACE_Condition_Attributes &attributes, - size_t preaolloc = ACE_DEFAULT_THREAD_MANAGER_PREALLOC, - size_t lwm = ACE_DEFAULT_THREAD_MANAGER_LWM, - size_t inc = ACE_DEFAULT_THREAD_MANAGER_INC, - size_t hwm = ACE_DEFAULT_THREAD_MANAGER_HWM); - ~ACE_Thread_Manager (void); - -#if ! defined (ACE_THREAD_MANAGER_LACKS_STATICS) - /// Get pointer to a process-wide ACE_Thread_Manager. - static ACE_Thread_Manager *instance (void); - - /// Set pointer to a process-wide ACE_Thread_Manager and return - /// existing pointer. - static ACE_Thread_Manager *instance (ACE_Thread_Manager *); - - /// Delete the dynamically allocated Singleton - static void close_singleton (void); -#endif /* ! defined (ACE_THREAD_MANAGER_LACKS_STATICS) */ - - /// No-op. Currently unused. - int open (size_t size = 0); - - /** - * Release all resources. - * By default, this method will wait until all threads exit. - * However, when called from close_singleton(), most global resources - * are destroyed and thus, close() does not try to wait; it simply cleans - * up internal thread records (the thread descriptor list). - */ - int close (void); - - /** - * Create a new thread, which executes @a func with argument @a arg. - * - * @param func The function that is called in the spawned thread. - * - * @param arg The value passed to each spawned thread's @a func. - * - * @param flags Flags to control attributes of the spawned threads. - * @sa ACE_OS::thr_create() for descriptions of the - * possible flags values and their interactions. - * - * @param t_id Pointer to a location to receive the spawned thread's - * ID. If 0, the ID is not returned. - * - * @param t_handle Pointer to a location to receive the spawned thread's - * thread handle. If 0, the handle is not returned. - * - * @param priority The priority at which the thread is spawned. - * - * @param grp_id The thread group that the spawned thread is - * added to. If -1 is specified, a new thread group is - * created for the spawned thread. - * - * @param stack Pointers to the base of a pre-allocated stack space - * for the thread's stack. If 0, the platform allocates - * stack space for the thread. If a stack is specified, - * it is recommended that @a stack_size also be supplied - * to specify the size of the stack. - * Not all platforms support pre-allocated stacks. If - * @a stack is specified for a platform which does not - * allow pre-allocated stack space this parameter is - * ignored. - * - * @param stack_size Indicate how large the thread's stack should be, in - * bytes. If a pre-allocated stack pointer is passed in - * @a stack, @a stack_size indicates the size of that - * stack area. If no pre-allocated stack is passed, - * the stack size specified is passed to the - * operating system to request that it allocate a stack - * of the specified size. - * - * @param thr_name Pointer to a name to assign to the spawned thread. - * This is only meaningful for platforms that have a - * capacity to name threads (e.g., VxWorks and some - * varieties of Pthreads). This argument is ignored if - * specified as 0 and on platforms that do not have the - * capability to name threads. - * - * @retval -1 on failure; @c errno contains an error value. - * @retval The group id of the spawned thread. - */ - int spawn (ACE_THR_FUNC func, - void *arg = 0, - long flags = THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED, - ACE_thread_t *t_id = 0, - ACE_hthread_t *t_handle = 0, - long priority = ACE_DEFAULT_THREAD_PRIORITY, - int grp_id = -1, - void *stack = 0, - size_t stack_size = ACE_DEFAULT_THREAD_STACKSIZE, - const char** thr_name = 0); - - /** - * Spawn a specified number of threads, all of which execute @a func - * with argument @a arg. - * - * @param n The number of threads to spawn. - * - * @param func The function that is called in the spawned thread. - * - * @param arg The value passed to each spawned thread's @a func. - * - * @param flags Flags to control attributes of the spawned threads. - * @sa ACE_OS::thr_create() for descriptions of the - * possible flags values and their interactions. - * - * @param priority The priority at which the threads are spawned. - * - * @param grp_id The thread group that the spawned threads are - * added to. If -1 is specified, a new thread group is - * created for the spawned threads. - * - * @param task The ACE_Task that the spawned threads are associated - * with. If 0, the threads are not associated with an - * ACE_Task. This argument is usually assigned by the - * ACE_Task_Base::activate() method to associate the - * spawned threads with the spawning ACE_Task object. - * - * @param thread_handles An array of @a n entries which will receive - * the thread handles of the spawned threads. - * - * @param stack An array of @a n pointers to pre-allocated stack space - * for each thread's stack. If specified as 0, the - * platform allocates stack space for each thread. If - * a stack is specified, it is recommended that a - * @a stack_size element also be supplied that specifies - * the size of the stack. - * Not all platforms support pre-allocated stacks. If - * @a stack is specified for a platform which does not - * allow pre-allocated stack space this parameter is - * ignored. - * - * @param stack_size An array of @a n values which indicate how large - * each thread's stack should be, in bytes. - * If pre-allocated stacks are passed in @a stacks, these - * sizes are for those stacks. If no pre-allocated stacks - * are passed, the stack sizes are specified to the - * operating system to request that it allocate stacks - * of the specified sizes. If an array entry is 0, the - * platform defaults are used for the corresponding thread. - * If a 0 array pointer is specified, platform defaults - * are used for all thread stack sizes. - * - * @param thr_name An array of names to assign to the spawned threads. - * This is only meaningful for platforms that have a - * capacity to name threads (e.g., VxWorks and some - * varieties of Pthreads). This argument is ignored if - * specified as 0 and on platforms that do not have the - * capability to name threads. - * - * ACE_Thread_Manager can manipulate threads in groups based on - * @a grp_id or @a task using functions such as kill_grp() or - * cancel_task(). - * - * @retval -1 on failure; @c errno contains an error value. - * @retval The group id of the threads. - */ - int spawn_n (size_t n, - ACE_THR_FUNC func, - void *arg = 0, - long flags = THR_NEW_LWP | THR_JOINABLE | THR_INHERIT_SCHED, - long priority = ACE_DEFAULT_THREAD_PRIORITY, - int grp_id = -1, - ACE_Task_Base *task = 0, - ACE_hthread_t thread_handles[] = 0, - void *stack[] = 0, - size_t stack_size[] = 0, - const char* thr_name[] = 0); - - /** - * Spawn a specified number of threads, all of which execute @a func - * with argument @a arg. - * - * @param thread_ids An array to receive the thread IDs of successfully - * spawned buffer. If 0, the thread IDs are not returned. - * If specified, the array must be at least @a n entries. - * - * @param n The number of threads to spawn. - * - * @param func The function that is called in the spawned thread. - * - * @param arg The value passed to each spawned thread's @a func. - * - * @param flags Flags to control attributes of the spawned threads. - * @sa ACE_OS::thr_create() for descriptions of the - * possible flags values and their interactions. - * - * @param priority The priority at which the threads are spawned. - * - * @param grp_id The thread group that the spawned threads are - * added to. If -1 is specified, a new thread group is - * created for the spawned threads. - * - * @param stack An array of @a n pointers to pre-allocated stack space - * for each thread's stack. If specified as 0, the - * platform allocates stack space for each thread. If - * a stack is specified, it is recommended that a - * @a stack_size element also be supplied that specifies - * the size of the stack. - * Not all platforms support pre-allocated stacks. If - * @a stack is specified for a platform which does not - * allow pre-allocated stack space this parameter is - * ignored. - * - * @param stack_size An array of @a n values which indicate how large - * each thread's stack should be, in bytes. - * If pre-allocated stacks are passed in @a stacks, these - * sizes are for those stacks. If no pre-allocated stacks - * are passed, the stack sizes are specified to the - * operating system to request that it allocate stacks - * of the specified sizes. If an array entry is 0, the - * platform defaults are used for the corresponding thread. - * If a 0 array pointer is specified, platform defaults - * are used for all thread stack sizes. - * - * @param thread_handles An array of @a n entries which will receive - * the thread handles of the spawned threads. - * - * @param task The ACE_Task that the spawned threads are associated - * with. If 0, the threads are not associated with an - * ACE_Task. This argument is usually assigned by the - * ACE_Task_Base::activate() method to associate the - * spawned threads with the spawning ACE_Task object. - * - * @param thr_name An array of names to assign to the spawned threads. - * This is only meaningful for platforms that have a - * capacity to name threads (e.g., VxWorks and some - * varieties of Pthreads). This argument is ignored if - * specified as 0 and on platforms that do not have the - * capability to name threads. - * - * ACE_Thread_Manager can manipulate threads in groups based on - * @a grp_id or @a task using functions such as kill_grp() or - * cancel_task(). - * - * @retval -1 on failure; @c errno contains an error value. - * @retval The group id of the threads. - - */ - int spawn_n (ACE_thread_t thread_ids[], - size_t n, - ACE_THR_FUNC func, - void *arg, - long flags, - long priority = ACE_DEFAULT_THREAD_PRIORITY, - int grp_id = -1, - void *stack[] = 0, - size_t stack_size[] = 0, - ACE_hthread_t thread_handles[] = 0, - ACE_Task_Base *task = 0, - const char* thr_name[] = 0); - - /** - * Called to clean up when a thread exits. - * - * @param do_thread_exit If non-0 then ACE_Thread::exit is called to - * exit the thread - * @param status If ACE_Thread_Exit is called, this is passed as - * the exit value of the thread. - * Should _not_ be called by main thread. - */ - ACE_THR_FUNC_RETURN exit (ACE_THR_FUNC_RETURN status = 0, - bool do_thread_exit = true); - - /** - * Block until there are no more threads running in this thread - * manager or @c timeout expires. - * - * @param timeout is treated as "absolute" time by default, but this - * can be changed to "relative" time by setting the @c - * use_absolute_time to false. - * @param abandon_detached_threads If true, @c wait() will first - * check thru its thread list for - * threads with THR_DETACHED or - * THR_DAEMON flags set and remove - * these threads. Notice that - * unlike other @c wait_*() methods, - * by default, @c wait() does wait on - * all thread spawned by this - * thread manager no matter the detached - * flags are set or not unless it is - * called with @c - * abandon_detached_threads flag set. - * @param use_absolute_time If true then treat @c timeout as - * absolute time, else relative time. - * @return 0 on success * and -1 on failure. - * - * @note If this function is called while the @c - * ACE_Object_Manager is shutting down (as a result of program - * rundown via @c ACE::fini()), it will not wait for any threads to - * complete. If you must wait for threads spawned by this thread - * manager to complete and you are in a ACE rundown situation (such - * as your object is being destroyed by the @c ACE_Object_Manager) - * you can use @c wait_grp() instead. - */ - int wait (const ACE_Time_Value *timeout = 0, - bool abandon_detached_threads = false, - bool use_absolute_time = true); - - /// Join a thread specified by @a tid. Do not wait on a detached thread. - int join (ACE_thread_t tid, ACE_THR_FUNC_RETURN *status = 0); - - /** - * Block until there are no more threads running in a group. - * Returns 0 on success and -1 on failure. Notice that wait_grp - * will not wait on detached threads. - */ - int wait_grp (int grp_id); - - /** - * Return the "real" handle to the calling thread, caching it if - * necessary in TSS to speed up subsequent lookups. This is - * necessary since on some platforms (e.g., Windows) we can't get this - * handle via direct method calls. Notice that you should *not* - * close the handle passed back from this method. It is used - * internally by Thread Manager. On the other hand, you *have to* - * use this internal thread handle when working on Thread_Manager. - * Return -1 if fail. - */ - int thr_self (ACE_hthread_t &); - - /** - * Return the unique ID of the calling thread. - * Same as calling ACE_Thread::self(). - */ - ACE_thread_t thr_self (void); - - /** - * Returns a pointer to the current ACE_Task_Base we're executing - * in if this thread is indeed running in an ACE_Task_Base, else - * return 0. - */ - ACE_Task_Base *task (void); - - /** - * @name Suspend and resume methods - * - * Suspend/resume is not supported on all platforms. For example, Pthreads - * does not support these functions. - */ - //@{ - - /// Suspend all threads - int suspend_all (void); - - /// Suspend a single thread. - int suspend (ACE_thread_t); - - /// Suspend a group of threads. - int suspend_grp (int grp_id); - - /** - * True if @a t_id is inactive (i.e., suspended), else false. Always - * return false if @a t_id is not managed by the Thread_Manager. - */ - int testsuspend (ACE_thread_t t_id); - - /// Resume all stopped threads - int resume_all (void); - - /// Resume a single thread. - int resume (ACE_thread_t); - - /// Resume a group of threads. - int resume_grp (int grp_id); - - /** - * True if @a t_id is active (i.e., resumed), else false. Always - * return false if @a t_id is not managed by the Thread_Manager. - */ - int testresume (ACE_thread_t t_id); - - //@} - - // = Send signals to one or more threads without blocking. - /** - * Send @a signum to all stopped threads. Not supported on platforms - * that do not have advanced signal support, such as Win32. - */ - int kill_all (int signum); - /** - * Send the @a signum to a single thread. Not supported on platforms - * that do not have advanced signal support, such as Win32. - */ - int kill (ACE_thread_t, int signum); - /** - * Send @a signum to a group of threads, not supported on platforms - * that do not have advanced signal support, such as Win32. - */ - int kill_grp (int grp_id, int signum); - - // = Cancel methods, which provides a cooperative thread-termination mechanism (will not block). - /** - * Cancel's all the threads. - */ - int cancel_all (int async_cancel = 0); - - /** - * Cancel a single thread. - */ - int cancel (ACE_thread_t, int async_cancel = 0); - - /** - * Cancel a group of threads. - */ - int cancel_grp (int grp_id, int async_cancel = 0); - - /** - * True if @a t_id is cancelled, else false. Always return false if - * @a t_id is not managed by the Thread_Manager. - */ - int testcancel (ACE_thread_t t_id); - - /** - * True if @a t_id has terminated (i.e., is no longer running), - * but the slot in the thread manager hasn't been reclaimed yet, - * else false. Always return false if @a t_id is not managed by the - * Thread_Manager. - */ - int testterminate (ACE_thread_t t_id); - - /// Set group ids for a particular thread id. - int set_grp (ACE_thread_t, - int grp_id); - - /// Get group ids for a particular thread id. - int get_grp (ACE_thread_t, - int &grp_id); - - /** - * @name Task-related operations - */ - //@{ - /** - * Block until there are no more threads running in a specified task. - * This method will not wait for either detached or daemon threads; - * the threads must have been spawned with the @c THR_JOINABLE flag. - * Upon successful completion, the threads have been joined, so further - * attempts to join with any of the waited-for threads will fail. - * - * @param task The ACE_Task_Base object whose threads are to waited for. - * - * @retval 0 Success. - * @retval -1 Failure (consult errno for further information). - */ - int wait_task (ACE_Task_Base *task); - - /** - * Suspend all threads in an ACE_Task. - */ - int suspend_task (ACE_Task_Base *task); - - /** - * Resume all threads in an ACE_Task. - */ - int resume_task (ACE_Task_Base *task); - - /** - * Send a signal @a signum to all threads in an ACE_Task. - */ - int kill_task (ACE_Task_Base *task, int signum); - - /** - * Cancel all threads in an ACE_Task. If @a async_cancel is non-0, - * then asynchronously cancel these threads if the OS platform - * supports cancellation. Otherwise, perform a "cooperative" - * cancellation. - */ - int cancel_task (ACE_Task_Base *task, int async_cancel = 0); - - //@} - - // = Collect thread handles in the thread manager. Notice that - // the collected information is just a snapshot. - /// Check if the thread is managed by the thread manager. Return true if - /// the thread is found, false otherwise. - int hthread_within (ACE_hthread_t handle); - int thread_within (ACE_thread_t tid); - - /// Returns the number of ACE_Task_Base in a group. - int num_tasks_in_group (int grp_id); - - /// Returns the number of threads in an ACE_Task_Base. - int num_threads_in_task (ACE_Task_Base *task); - - /** - * Returns a list of ACE_Task_Base pointers corresponding to the tasks - * that have active threads in a specified thread group. - * - * @param grp_id The thread group ID to obtain task pointers for. - * - * @param task_list is a pointer to an array to receive the list of pointers. - * The caller is responsible for supplying an array with at - * least @arg n entries. - * - * @param n The maximum number of ACE_Task_Base pointers to write - * in @arg task_list. - * - * @retval If successful, the number of pointers returned, which will be - * no greater than @arg n. Returns -1 on error. - * - * @note This method has no way to indicate if there are more than - * @arg n ACE_Task_Base pointers available. Therefore, it may be - * wise to guess a larger value of @arg n than one thinks in cases - * where the exact number of tasks is not known. - * - * @sa num_tasks_in_group(), task_all_list() - */ - ssize_t task_list (int grp_id, - ACE_Task_Base *task_list[], - size_t n); - - /** - * Returns in @a thread_list a list of up to @a n thread ids in an - * ACE_Task_Base. The caller must allocate the memory for - * @a thread_list. In case of an error, -1 is returned. If no - * requested values are found, 0 is returned, otherwise correct - * number of retrieved values are returned. - */ - ssize_t thread_list (ACE_Task_Base *task, - ACE_thread_t thread_list[], - size_t n); - - /** - * Returns in @a hthread_list a list of up to @a n thread handles in - * an ACE_Task_Base. The caller must allocate memory for - * @a hthread_list. In case of an error, -1 is returned. If no - * requested values are found, 0 is returned, otherwise correct - * number of retrieved values are returned. - */ - ssize_t hthread_list (ACE_Task_Base *task, - ACE_hthread_t hthread_list[], - size_t n); - - /** - * Returns in @a thread_list a list of up to @a n thread ids in a - * group @a grp_id. The caller must allocate the memory for - * @a thread_list. In case of an error, -1 is returned. If no - * requested values are found, 0 is returned, otherwise correct - * number of retrieved values are returned. - */ - ssize_t thread_grp_list (int grp_id, - ACE_thread_t thread_list[], - size_t n); - - /** - * Returns in @a hthread_list a list of up to @a n thread handles in - * a group @a grp_id. The caller must allocate memory for - * @a hthread_list. - */ - ssize_t hthread_grp_list (int grp_id, - ACE_hthread_t hthread_list[], - size_t n); - - /** - * Returns a list of ACE_Task_Base pointers corresponding to the tasks - * that have active threads managed by this instance. - * - * @param task_list is a pointer to an array to receive the list of pointers. - * The caller is responsible for supplying an array with at - * least @arg n entries. - * - * @param n The maximum number of ACE_Task_Base pointers to write - * in @arg task_list. - * - * @retval If successful, the number of pointers returned, which will be - * no greater than @arg n. Returns -1 on error. - * - * @note This method has no way to indicate if there are more than - * @arg n ACE_Task_Base pointers available. Therefore, it may be - * wise to guess a larger value of @arg n than one thinks in cases - * where the exact number of tasks is not known. - * - * @sa count_threads() - */ - ssize_t task_all_list (ACE_Task_Base *task_list[], - size_t n); - - /** - * Returns in @a thread_list a list of up to @a n thread ids. The - * caller must allocate the memory for @a thread_list. In case of an - * error, -1 is returned. If no requested values are found, 0 is - * returned, otherwise correct number of retrieved values are - * returned. - */ - ssize_t thread_all_list (ACE_thread_t thread_list[], - size_t n); - - /// Set group ids for a particular task. - int set_grp (ACE_Task_Base *task, int grp_id); - - /// Get group ids for a particular task. - int get_grp (ACE_Task_Base *task, int &grp_id); - - /// Return a count of the current number of threads active in the - /// Thread_Manager. - size_t count_threads (void) const; - - /// Get the state of the thread. Returns false if the thread is not - /// managed by this thread manager. - int thr_state (ACE_thread_t id, ACE_UINT32& state); - - /** - * Register an At_Thread_Exit hook and the ownership is acquire by - * Thread_Descriptor, this is the usual case when the AT is dynamically - * allocated. - */ - int at_exit (ACE_At_Thread_Exit* cleanup); - - /// Register an At_Thread_Exit hook and the ownership is retained for the - /// caller. Normally used when the at_exit hook is created in stack. - int at_exit (ACE_At_Thread_Exit& cleanup); - - /** - * - ***** - * @deprecated This function is deprecated. Please use the previous two - * at_exit method. Notice that you should avoid mixing this method - * with the previous two at_exit methods. - ***** - * - * Register an object (or array) for cleanup at - * thread termination. "cleanup_hook" points to a (global, or - * static member) function that is called for the object or array - * when it to be destroyed. It may perform any necessary cleanup - * specific for that object or its class. "param" is passed as the - * second parameter to the "cleanup_hook" function; the first - * parameter is the object (or array) to be destroyed. - * "cleanup_hook", for example, may delete the object (or array). - * If @a cleanup_hook == 0, the @a object will _NOT_ get cleanup at - * thread exit. You can use this to cancel the previously added - * at_exit. - */ - int at_exit (void *object, - ACE_CLEANUP_FUNC cleanup_hook, - void *param); - - /// Access function to determine whether the Thread_Manager will - /// wait for its thread to exit or not when being closing down. - void wait_on_exit (int dowait); - int wait_on_exit (void); - - /// Dump the state of an object. - void dump (void); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - // = Accessors for ACE_Thread_Descriptors. - /** - * Get a pointer to the calling thread's own thread_descriptor. - * This must be called from a spawn thread. This function will - * fetch the info from TSS. - */ - ACE_Thread_Descriptor *thread_desc_self (void); - - /// Return a pointer to the thread's Thread_Descriptor, - /// 0 if fail. - ACE_Thread_Descriptor *thread_descriptor (ACE_thread_t); - - /// Return a pointer to the thread's Thread_Descriptor, - /// 0 if fail. - ACE_Thread_Descriptor *hthread_descriptor (ACE_hthread_t); - - /// Create a new thread (must be called with locks held). - int spawn_i (ACE_THR_FUNC func, - void *arg, - long flags, - ACE_thread_t * = 0, - ACE_hthread_t *t_handle = 0, - long priority = ACE_DEFAULT_THREAD_PRIORITY, - int grp_id = -1, - void *stack = 0, - size_t stack_size = 0, - ACE_Task_Base *task = 0, - const char** thr_name = 0); - - /// Run the registered hooks when the thread exits. - void run_thread_exit_hooks (int i); - - /// Locate the index of the table slot occupied by @a t_id. Returns - /// -1 if @a t_id is not in the table doesn't contain @a t_id. - ACE_Thread_Descriptor *find_thread (ACE_thread_t t_id); - - /// Locate the index of the table slot occupied by @a h_id. Returns - /// -1 if @a h_id is not in the table doesn't contain @a h_id. - ACE_Thread_Descriptor *find_hthread (ACE_hthread_t h_id); - - /** - * Locate the thread descriptor address of the list occupied by - * @a task. Returns 0 if @a task is not in the table doesn't contain - * @a task. - */ - ACE_Thread_Descriptor *find_task (ACE_Task_Base *task, - size_t slot = 0); - - /// Insert a thread in the table (checks for duplicates). - int insert_thr (ACE_thread_t t_id, - ACE_hthread_t, - int grp_id = -1, - long flags = 0); - - /// Append a thread in the table (adds at the end, growing the table - /// if necessary). - int append_thr (ACE_thread_t t_id, ACE_hthread_t, - ACE_UINT32, - int grp_id, - ACE_Task_Base *task = 0, - long flags = 0, - ACE_Thread_Descriptor *td = 0); - - /// Remove thread from the table. - void remove_thr (ACE_Thread_Descriptor *td, - int close_handler); - - /// Remove all threads from the table. - void remove_thr_all (void); - - // = The following four methods implement a simple scheme for - // operating on a collection of threads atomically. - - /** - * Efficiently check whether @a thread is in a particular @a state. - * This call updates the TSS cache if possible to speed up - * subsequent searches. - */ - int check_state (ACE_UINT32 state, - ACE_thread_t thread, - int enable = 1); - - /// Apply @a func to all members of the table that match the @a task - int apply_task (ACE_Task_Base *task, - ACE_THR_MEMBER_FUNC func, - int = 0); - - /// Apply @a func to all members of the table that match the @a grp_id. - int apply_grp (int grp_id, - ACE_THR_MEMBER_FUNC func, - int arg = 0); - - /// Apply @a func to all members of the table. - int apply_all (ACE_THR_MEMBER_FUNC, - int = 0); - - /// Join the thread described in @a td. - int join_thr (ACE_Thread_Descriptor *td, - int = 0); - - /// Resume the thread described in @a td. - int resume_thr (ACE_Thread_Descriptor *td, - int = 0); - - /// Suspend the thread described in @a td. - int suspend_thr (ACE_Thread_Descriptor *td, - int = 0); - - /// Send signal @a signum to the thread described in @a td. - int kill_thr (ACE_Thread_Descriptor *td, - int signum); - - /// Set the cancellation flag for the thread described in @a td. - int cancel_thr (ACE_Thread_Descriptor *td, - int async_cancel = 0); - - /// Register a thread as terminated and put it into the terminated_thr_list_. - int register_as_terminated (ACE_Thread_Descriptor *td); - - /// Setting the static ACE_TSS_TYPE (ACE_Thread_Exit) *thr_exit_ pointer. - static int set_thr_exit (ACE_TSS_TYPE (ACE_Thread_Exit) *ptr); - - /** - * Keeping a list of thread descriptors within the thread manager. - * Double-linked list enables us to cache the entries in TSS - * and adding/removing thread descriptor entries without - * affecting other thread's descriptor entries. - */ - ACE_Double_Linked_List thr_list_; - -#if !defined (ACE_HAS_VXTHREADS) - /// Collect terminated but not yet joined thread entries. - ACE_Double_Linked_List terminated_thr_list_; -#endif /* !ACE_HAS_VXTHREADS */ - - /// Collect pointers to thread descriptors of threads to be removed later. - ACE_Unbounded_Queue thr_to_be_removed_; - - /// Keeps track of the next group id to assign. - int grp_id_; - - /// Set if we want the Thread_Manager to wait on all threads before - /// being closed, reset otherwise. - int automatic_wait_; - - // = ACE_Thread_Mutex and condition variable for synchronizing termination. -#if defined (ACE_HAS_THREADS) - /// Serialize access to the zero_cond_. - ACE_Thread_Mutex lock_; - - /// Keep track of when there are no more threads. - ACE_Condition_Thread_Mutex zero_cond_; -#endif /* ACE_HAS_THREADS */ - - ACE_Locked_Free_List thread_desc_freelist_; - -#if defined (ACE_HAS_THREADS) && defined (ACE_LACKS_PTHREAD_JOIN) - ACE_Condition_Thread_Mutex join_cond_; -#endif - -private: -#if ! defined (ACE_THREAD_MANAGER_LACKS_STATICS) - /// Pointer to a process-wide ACE_Thread_Manager. - static ACE_Thread_Manager *thr_mgr_; - - /// Must delete the thr_mgr_ if true. - static bool delete_thr_mgr_; - - /// Global ACE_TSS (ACE_Thread_Exit) object ptr. - static ACE_TSS_TYPE (ACE_Thread_Exit) *thr_exit_; -#endif /* ! defined (ACE_THREAD_MANAGER_LACKS_STATICS) */ -}; - -#if defined (ACE_THREAD_MANAGER_LACKS_STATICS) -#define ACE_THREAD_MANAGER_SINGLETON_DEFINE \ - ACE_Singleton; -typedef ACE_Singleton ACE_THREAD_MANAGER_SINGLETON; -#endif /* defined (ACE_THREAD_MANAGER_LACKS_STATICS) */ - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Thread_Manager.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_THREAD_MANAGER_H */ diff --git a/deps/acelite/ace/Thread_Manager.inl b/deps/acelite/ace/Thread_Manager.inl deleted file mode 100644 index e3ddda3a8..000000000 --- a/deps/acelite/ace/Thread_Manager.inl +++ /dev/null @@ -1,302 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_At_Thread_Exit::ACE_At_Thread_Exit (void) - : next_ (0), - td_ (0), - was_applied_ (false), - is_owner_ (true) -{ -} - -ACE_INLINE bool -ACE_At_Thread_Exit::was_applied() const -{ - return was_applied_; -} - -ACE_INLINE bool -ACE_At_Thread_Exit::was_applied (bool applied) -{ - was_applied_ = applied; - if (was_applied_) - td_ = 0; - return was_applied_; -} - -ACE_INLINE bool -ACE_At_Thread_Exit::is_owner() const -{ - return is_owner_; -} - -ACE_INLINE bool -ACE_At_Thread_Exit::is_owner (bool owner) -{ - is_owner_ = owner; - return is_owner_; -} - -ACE_INLINE void -ACE_At_Thread_Exit::do_apply (void) -{ - if (!this->was_applied_ && this->is_owner_) - td_->at_pop(); -} - -ACE_INLINE -ACE_At_Thread_Exit_Func::ACE_At_Thread_Exit_Func (void *object, - ACE_CLEANUP_FUNC func, - void *param) - : object_(object), - func_(func), - param_(param) -{ -} - -ACE_INLINE -ACE_Thread_Descriptor_Base::ACE_Thread_Descriptor_Base (void) - : ACE_OS_Thread_Descriptor (), - thr_id_ (ACE_OS::NULL_thread), - thr_handle_ (ACE_OS::NULL_hthread), - grp_id_ (0), - thr_state_ (ACE_Thread_Manager::ACE_THR_IDLE), - task_ (0), - next_ (0), - prev_ (0) -{ -} - -ACE_INLINE -ACE_Thread_Descriptor_Base::~ACE_Thread_Descriptor_Base (void) -{ -} - -ACE_INLINE bool -ACE_Thread_Descriptor_Base::operator== ( - const ACE_Thread_Descriptor_Base &rhs) const -{ - return - ACE_OS::thr_cmp (this->thr_handle_, rhs.thr_handle_) - && ACE_OS::thr_equal (this->thr_id_, rhs.thr_id_); -} - -ACE_INLINE bool -ACE_Thread_Descriptor_Base::operator!=(const ACE_Thread_Descriptor_Base &rhs) const -{ - return !(*this == rhs); -} - -ACE_INLINE ACE_Task_Base * -ACE_Thread_Descriptor_Base::task (void) const -{ - ACE_TRACE ("ACE_Thread_Descriptor_Base::task"); - return this->task_; -} - -// Group ID. - -ACE_INLINE int -ACE_Thread_Descriptor_Base::grp_id (void) const -{ - ACE_TRACE ("ACE_Thread_Descriptor_Base::grp_id"); - return grp_id_; -} - -// Current state of the thread. -ACE_INLINE ACE_UINT32 -ACE_Thread_Descriptor_Base::state (void) const -{ - ACE_TRACE ("ACE_Thread_Descriptor_Base::state"); - return thr_state_; -} - -// Reset this base descriptor. -ACE_INLINE void -ACE_Thread_Descriptor_Base::reset (void) -{ - ACE_TRACE ("ACE_Thread_Descriptor_Base::reset"); - this->thr_id_ = ACE_OS::NULL_thread; - this->thr_handle_ = ACE_OS::NULL_hthread; - this->grp_id_ = 0; - this->thr_state_ = ACE_Thread_Manager::ACE_THR_IDLE; - this->task_ = 0; - this->flags_ = 0; -} - -// Unique thread id. -ACE_INLINE ACE_thread_t -ACE_Thread_Descriptor::self (void) const -{ - ACE_TRACE ("ACE_Thread_Descriptor::self"); - return this->thr_id_; -} - -// Unique kernel-level thread handle. - -ACE_INLINE void -ACE_Thread_Descriptor::self (ACE_hthread_t &handle) -{ - ACE_TRACE ("ACE_Thread_Descriptor::self"); - handle = this->thr_handle_; -} - -ACE_INLINE void -ACE_Thread_Descriptor::log_msg_cleanup (ACE_Log_Msg* log_msg) - -{ - log_msg_ = log_msg; -} - -// Set the pointer -ACE_INLINE void -ACE_Thread_Descriptor::set_next (ACE_Thread_Descriptor *td) -{ - ACE_TRACE ("ACE_Thread_Descriptor::set_next"); - this->next_ = td; -} - -// Get the pointer -ACE_INLINE ACE_Thread_Descriptor * -ACE_Thread_Descriptor::get_next (void) const -{ - ACE_TRACE ("ACE_Thread_Descriptor::get_next"); - return static_cast (this->next_); -} - -// Reset this thread descriptor -ACE_INLINE void -ACE_Thread_Descriptor::reset (ACE_Thread_Manager *tm) -{ - ACE_TRACE ("ACE_Thread_Descriptor::reset"); - this->ACE_Thread_Descriptor_Base::reset (); - this->at_exit_list_ = 0; - // Start the at_exit hook list. - this->tm_ = tm; - // Setup the Thread_Manager. - this->log_msg_ = 0; - this->terminated_ = false; -} - -ACE_INLINE ACE_Thread_Descriptor * -ACE_Thread_Manager::thread_desc_self (void) -{ - // This method must be called with lock held. - - // Try to get it from cache. - ACE_Thread_Descriptor *desc = ACE_LOG_MSG->thr_desc (); - -#if 1 - // ACE_ASSERT (desc != 0); - // Thread descriptor should always get cached. -#else - if (desc == 0) - { - ACE_thread_t id = ACE_OS::thr_self (); - - desc = this->find_thread (id); - - // Thread descriptor adapter might not have been put into the - // list yet. - if (desc != 0) - // Update the TSS cache. - ACE_LOG_MSG->thr_desc (desc); - } -#endif - return desc; -} - -// Return the unique ID of the thread. - -ACE_INLINE ACE_thread_t -ACE_Thread_Manager::thr_self (void) -{ - ACE_TRACE ("ACE_Thread_Manager::thr_self"); - return ACE_Thread::self (); -} - -ACE_INLINE ACE_Task_Base * -ACE_Thread_Manager::task (void) -{ - ACE_TRACE ("ACE_Thread_Manager::task"); - - ACE_Thread_Descriptor *td = this->thread_desc_self () ; - - if (td == 0) - return 0; - else - return td->task (); -} - -ACE_INLINE int -ACE_Thread_Manager::open (size_t) -{ - // Currently no-op. - return 0; -} - -ACE_INLINE int -ACE_Thread_Manager::at_exit (ACE_At_Thread_Exit* at) -{ - ACE_Thread_Descriptor *td = this->thread_desc_self (); - if (td == 0) - return -1; - else - return td->at_exit (at); -} - -ACE_INLINE int -ACE_Thread_Manager::at_exit (ACE_At_Thread_Exit& at) -{ - ACE_Thread_Descriptor *td = this->thread_desc_self (); - if (td == 0) - return -1; - else - return td->at_exit (at); -} - -ACE_INLINE int -ACE_Thread_Manager::at_exit (void *object, - ACE_CLEANUP_FUNC cleanup_hook, - void *param) -{ - ACE_Thread_Descriptor *td = this->thread_desc_self (); - if (td == 0) - return -1; - else - return td->at_exit (object, cleanup_hook, param); -} - -ACE_INLINE void -ACE_Thread_Manager::wait_on_exit (int do_wait) -{ - this->automatic_wait_ = do_wait; -} - -ACE_INLINE int -ACE_Thread_Manager::wait_on_exit (void) -{ - return this->automatic_wait_; -} - -ACE_INLINE int -ACE_Thread_Manager::register_as_terminated (ACE_Thread_Descriptor *td) -{ -#if defined (ACE_HAS_VXTHREADS) - ACE_UNUSED_ARG (td); -#else /* ! ACE_HAS_VXTHREADS */ - ACE_Thread_Descriptor_Base *tdb = 0; - ACE_NEW_RETURN (tdb, ACE_Thread_Descriptor_Base (*td), -1); - this->terminated_thr_list_.insert_tail (tdb); -#endif /* !ACE_HAS_VXTHREADS */ - return 0; -} - -ACE_INLINE size_t -ACE_Thread_Manager::count_threads (void) const -{ - return this->thr_list_.size (); -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Thread_Mutex.cpp b/deps/acelite/ace/Thread_Mutex.cpp deleted file mode 100644 index b51505f7b..000000000 --- a/deps/acelite/ace/Thread_Mutex.cpp +++ /dev/null @@ -1,60 +0,0 @@ -/** - * @file Thread_Mutex.cpp - * - * Originally in Synch.cpp - * - * @author Douglas C. Schmidt - */ - -#include "ace/Thread_Mutex.h" - -#if defined (ACE_HAS_THREADS) - -#if !defined (__ACE_INLINE__) -#include "ace/Thread_Mutex.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Log_Category.h" -#include "ace/Malloc_T.h" - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Mutex) - -void -ACE_Thread_Mutex::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Thread_Mutex::dump"); - - ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACELIB_DEBUG ((LM_DEBUG, ACE_TEXT ("\n"))); - ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Thread_Mutex::~ACE_Thread_Mutex (void) -{ -// ACE_TRACE ("ACE_Thread_Mutex::~ACE_Thread_Mutex"); - this->remove (); -} - -ACE_Thread_Mutex::ACE_Thread_Mutex (const ACE_TCHAR *name, ACE_mutexattr_t *arg) - : removed_ (false) -{ -// ACE_TRACE ("ACE_Thread_Mutex::ACE_Thread_Mutex"); - - if (ACE_OS::thread_mutex_init (&this->lock_, - 0, - name, - arg) != 0) - ACELIB_ERROR ((LM_ERROR, - ACE_TEXT ("%p\n"), - ACE_TEXT ("ACE_Thread_Mutex::ACE_Thread_Mutex"))); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_THREADS */ diff --git a/deps/acelite/ace/Thread_Mutex.h b/deps/acelite/ace/Thread_Mutex.h deleted file mode 100644 index 9270aa68a..000000000 --- a/deps/acelite/ace/Thread_Mutex.h +++ /dev/null @@ -1,173 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Thread_Mutex.h - * - * Moved from Synch.h. - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_THREAD_MUTEX_H -#define ACE_THREAD_MUTEX_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (ACE_HAS_THREADS) -# include "ace/Null_Mutex.h" -#else /* ACE_HAS_THREADS */ -// ACE platform supports some form of threading. - -#include /**/ "ace/ACE_export.h" -#include "ace/OS_NS_Thread.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Thread_Mutex - * - * @brief ACE_Thread_Mutex wrapper (only valid for threads in the same - * process). - * - * This implementation is optimized for locking threads that are - * in the same process. It maps to s on NT - * and with set to on UNIX. - * ACE_Thread_Mutex is recursive on some platforms (like - * Win32). However, on most platforms (like Solaris) it is not - * recursive. To be totally safe and portable, developers - * should use ACE_Recursive_Thread_Mutex when they need a - * recursive mutex. - */ -class ACE_Export ACE_Thread_Mutex -{ -public: - /// Constructor. - ACE_Thread_Mutex (const ACE_TCHAR *name = 0, - ACE_mutexattr_t *attributes = 0); - - /// Implicitly destroy the mutex. - ~ACE_Thread_Mutex (void); - - /** - * Explicitly destroy the mutex. Note that only one thread should - * call this method since it doesn't protect against race - * conditions. - */ - int remove (void); - - /// Acquire lock ownership (wait on queue if necessary). - int acquire (void); - - /** - * Block the thread until we acquire the mutex or until @a tv times - * out, in which case -1 is returned with @c errno == @c ETIME. Note - * that @a tv is assumed to be in "absolute" rather than "relative" - * time. The value of @a tv is updated upon return to show the - * actual (absolute) acquisition time. - */ - int acquire (ACE_Time_Value &tv); - - /** - * If @a tv == 0 the call acquire() directly. Otherwise, Block the - * thread until we acquire the mutex or until @a tv times out, in - * which case -1 is returned with @c errno == @c ETIME. Note that - * @a tv is assumed to be in "absolute" rather than "relative" time. - * The value of @a tv is updated upon return to show the actual - * (absolute) acquisition time. - */ - int acquire (ACE_Time_Value *tv); - - /** - * Conditionally acquire lock (i.e., don't wait on queue). Returns - * -1 on failure. If we "failed" because someone else already had - * the lock, @c errno is set to @c EBUSY. - */ - int tryacquire (void); - - /// Release lock and unblock a thread at head of queue. - int release (void); - - /** - * Acquire mutex ownership. This calls acquire() and is only here - * to make the ACE_Thread_Mutex interface consistent with the - * other synchronization APIs. - */ - int acquire_read (void); - - /** - * Acquire mutex ownership. This calls acquire() and is only here - * to make the ACE_Thread_Mutex interface consistent with the - * other synchronization APIs. - */ - int acquire_write (void); - - /** - * Conditionally acquire mutex (i.e., won't block). This calls - * tryacquire() and is only here to make the ACE_Thread_Mutex - * interface consistent with the other synchronization APIs. - * Returns -1 on failure. If we "failed" because someone else - * already had the lock, @c errno is set to @c EBUSY. - */ - int tryacquire_read (void); - - /** - * Conditionally acquire mutex (i.e., won't block). This calls - * tryacquire() and is only here to make the ACE_Thread_Mutex - * interface consistent with the other synchronization APIs. - * Returns -1 on failure. If we "failed" because someone else - * already had the lock, @c errno is set to @c EBUSY. - */ - int tryacquire_write (void); - - /** - * This is only here to make the ACE_Thread_Mutex interface - * consistent with the other synchronization APIs. Assumes the - * caller has already acquired the mutex using one of the above - * calls, and returns 0 (success) always. - */ - int tryacquire_write_upgrade (void); - - /// Return the underlying mutex. - const ACE_thread_mutex_t &lock (void) const; - ACE_thread_mutex_t &lock (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -protected: - /// Mutex type that supports single-process locking efficiently. - ACE_thread_mutex_t lock_; - - /// Keeps track of whether remove() has been called yet to avoid - /// multiple calls, e.g., explicitly and implicitly in the - /// destructor. This flag isn't protected by a lock, so make sure - /// that you don't have multiple threads simultaneously calling - /// on the same object, which is a bad idea anyway... - bool removed_; - -private: - // = Prevent assignment and initialization. - void operator= (const ACE_Thread_Mutex &); - ACE_Thread_Mutex (const ACE_Thread_Mutex &); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Thread_Mutex.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* !ACE_HAS_THREADS */ - -#include /**/ "ace/post.h" -#endif /* ACE_THREAD_MUTEX_H */ diff --git a/deps/acelite/ace/Thread_Mutex.inl b/deps/acelite/ace/Thread_Mutex.inl deleted file mode 100644 index e3d271932..000000000 --- a/deps/acelite/ace/Thread_Mutex.inl +++ /dev/null @@ -1,101 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE const ACE_thread_mutex_t & -ACE_Thread_Mutex::lock (void) const -{ -// ACE_TRACE ("ACE_Thread_Mutex::lock"); - return this->lock_; -} - -ACE_INLINE ACE_thread_mutex_t & -ACE_Thread_Mutex::lock (void) -{ -// ACE_TRACE ("ACE_Thread_Mutex::lock"); - return this->lock_; -} - -ACE_INLINE int -ACE_Thread_Mutex::acquire_read (void) -{ -// ACE_TRACE ("ACE_Thread_Mutex::acquire_read"); - return ACE_OS::thread_mutex_lock (&this->lock_); -} - -ACE_INLINE int -ACE_Thread_Mutex::acquire_write (void) -{ -// ACE_TRACE ("ACE_Thread_Mutex::acquire_write"); - return ACE_OS::thread_mutex_lock (&this->lock_); -} - -ACE_INLINE int -ACE_Thread_Mutex::tryacquire_read (void) -{ -// ACE_TRACE ("ACE_Thread_Mutex::tryacquire_read"); - return ACE_OS::thread_mutex_trylock (&this->lock_); -} - -ACE_INLINE int -ACE_Thread_Mutex::tryacquire_write (void) -{ -// ACE_TRACE ("ACE_Thread_Mutex::tryacquire_write"); - return ACE_OS::thread_mutex_trylock (&this->lock_); -} - -ACE_INLINE int -ACE_Thread_Mutex::tryacquire_write_upgrade (void) -{ -// ACE_TRACE ("ACE_Thread_Mutex::tryacquire_write_upgrade"); - return 0; -} - -ACE_INLINE int -ACE_Thread_Mutex::acquire (void) -{ -// ACE_TRACE ("ACE_Thread_Mutex::acquire"); - return ACE_OS::thread_mutex_lock (&this->lock_); -} - -ACE_INLINE int -ACE_Thread_Mutex::acquire (ACE_Time_Value &tv) -{ - // ACE_TRACE ("ACE_Thread_Mutex::acquire"); - return ACE_OS::thread_mutex_lock (&this->lock_, tv); -} - -ACE_INLINE int -ACE_Thread_Mutex::acquire (ACE_Time_Value *tv) -{ - // ACE_TRACE ("ACE_Thread_Mutex::acquire"); - return ACE_OS::thread_mutex_lock (&this->lock_, tv); -} - -ACE_INLINE int -ACE_Thread_Mutex::tryacquire (void) -{ -// ACE_TRACE ("ACE_Thread_Mutex::tryacquire"); - return ACE_OS::thread_mutex_trylock (&this->lock_); -} - -ACE_INLINE int -ACE_Thread_Mutex::release (void) -{ -// ACE_TRACE ("ACE_Thread_Mutex::release"); - return ACE_OS::thread_mutex_unlock (&this->lock_); -} - -ACE_INLINE int -ACE_Thread_Mutex::remove (void) -{ -// ACE_TRACE ("ACE_Thread_Mutex::remove"); - int result = 0; - if (!this->removed_) - { - this->removed_ = true; - result = ACE_OS::thread_mutex_destroy (&this->lock_); - } - return result; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Thread_Semaphore.cpp b/deps/acelite/ace/Thread_Semaphore.cpp deleted file mode 100644 index 1fa0bf178..000000000 --- a/deps/acelite/ace/Thread_Semaphore.cpp +++ /dev/null @@ -1,66 +0,0 @@ -/** - * @file Thread_Semaphore.cpp - * - * Originally in Synch.cpp - * - * @author Douglas C. Schmidt - */ - -#include "ace/Thread_Semaphore.h" - -#if defined (ACE_HAS_THREADS) - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/Thread_Semaphore.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/ACE.h" - - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Semaphore) - -void -ACE_Thread_Semaphore::dump (void) const -{ -#if defined (ACE_HAS_DUMP) -// ACE_TRACE ("ACE_Thread_Semaphore::dump"); - - ACE_Semaphore::dump (); -#endif /* ACE_HAS_DUMP */ -} - -ACE_Thread_Semaphore::ACE_Thread_Semaphore (unsigned int count, - const ACE_TCHAR *name, - void *arg, - int max) - : ACE_Semaphore (count, USYNC_THREAD, name, arg, max) -{ -// ACE_TRACE ("ACE_Thread_Semaphore::ACE_Thread_Semaphore"); -} - -/*****************************************************************************/ - -ACE_Thread_Semaphore * -ACE_Malloc_Lock_Adapter_T::operator () (const ACE_TCHAR *name) -{ - ACE_Thread_Semaphore *p = 0; - if (name == 0) - ACE_NEW_RETURN (p, ACE_Thread_Semaphore (1, name), 0); - else - ACE_NEW_RETURN (p, ACE_Thread_Semaphore (1, ACE::basename (name, - ACE_DIRECTORY_SEPARATOR_CHAR)), - 0); - return p; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_HAS_THREADS */ diff --git a/deps/acelite/ace/Thread_Semaphore.h b/deps/acelite/ace/Thread_Semaphore.h deleted file mode 100644 index c59e25ba9..000000000 --- a/deps/acelite/ace/Thread_Semaphore.h +++ /dev/null @@ -1,85 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Thread_Semaphore.h - * - * Moved from Synch.h. - * - * @author Douglas C. Schmidt - */ -//========================================================================== - -#ifndef ACE_THREAD_SEMAPHORE_H -#define ACE_THREAD_SEMAPHORE_H -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (ACE_HAS_THREADS) -# include "ace/Null_Semaphore.h" -#else /* ACE_HAS_THREADS */ -// ACE platform supports some form of threading. - -#include "ace/Semaphore.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Thread_Semaphore - * - * @brief Wrapper for Dijkstra style general semaphores that work - * only within one process. - */ -class ACE_Export ACE_Thread_Semaphore : public ACE_Semaphore -{ -public: - /// Initialize the semaphore, with an initial value of @a count, - /// maximum value of @a max, and unlocked by default. - ACE_Thread_Semaphore (unsigned int count = 1, // By default make this unlocked. - const ACE_TCHAR *name = 0, - void * = 0, - int max = 0x7FFFFFFF); - - /// Default destructor. - ~ACE_Thread_Semaphore (void); - - /// Dump the state of an object. - void dump (void) const; - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; -}; - -/*****************************************************************************/ - -template class ACE_Malloc_Lock_Adapter_T; - -/** - * @brief Template specialization of ACE_Malloc_Lock_Adapter_T for - * ACE_Thread_Semaphore. - * - * This is needed since the ctor for ACE_Thread_Semaphore doesn't match - * the standard form used by other lock strategy classes. - */ -template<> -class ACE_Export ACE_Malloc_Lock_Adapter_T -{ -public: - ACE_Thread_Semaphore * operator () (const ACE_TCHAR *name); -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Thread_Semaphore.inl" -#endif /* __ACE_INLINE__ */ - -#endif /* !ACE_HAS_THREADS */ - -#include /**/ "ace/post.h" -#endif /* ACE_THREAD_SEMAPHORE_H */ diff --git a/deps/acelite/ace/Thread_Semaphore.inl b/deps/acelite/ace/Thread_Semaphore.inl deleted file mode 100644 index 9a2a0affe..000000000 --- a/deps/acelite/ace/Thread_Semaphore.inl +++ /dev/null @@ -1,9 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE -ACE_Thread_Semaphore::~ACE_Thread_Semaphore (void) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Throughput_Stats.cpp b/deps/acelite/ace/Throughput_Stats.cpp deleted file mode 100644 index 6ecc4c8aa..000000000 --- a/deps/acelite/ace/Throughput_Stats.cpp +++ /dev/null @@ -1,94 +0,0 @@ -#include "ace/Throughput_Stats.h" - -#include "ace/OS_NS_stdio.h" -#include "ace/OS_NS_string.h" -#include "ace/High_Res_Timer.h" -#include "ace/Log_Category.h" - - - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Throughput_Stats::ACE_Throughput_Stats (void) - : ACE_Basic_Stats () - , throughput_last_ (0) -{ -} - -void -ACE_Throughput_Stats::sample (ACE_UINT64 throughput, - ACE_UINT64 latency) -{ - this->ACE_Basic_Stats::sample (latency); - - if (this->samples_count () == 1u) - { - this->throughput_last_ = throughput; - } -} - -void -ACE_Throughput_Stats::accumulate (const ACE_Throughput_Stats &rhs) -{ - if (rhs.samples_count () == 0u) - return; - - this->ACE_Basic_Stats::accumulate (rhs); - - if (this->samples_count () == 0u) - { - this->throughput_last_ = rhs.throughput_last_; - } - else if (this->throughput_last_ < rhs.throughput_last_) - { - this->throughput_last_ = rhs.throughput_last_; - } -} - -void -ACE_Throughput_Stats::dump_results (const ACE_TCHAR* msg, - ACE_Basic_Stats::scale_factor_type sf) -{ - if (this->samples_count () == 0u) - { - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("%s : no data collected\n"), msg)); - return; - } - - this->ACE_Basic_Stats::dump_results (msg, sf); - - ACE_Throughput_Stats::dump_throughput (msg, sf, - this->throughput_last_, - this->samples_count ()); -} - -void -ACE_Throughput_Stats::dump_throughput (const ACE_TCHAR *msg, - ACE_Basic_Stats::scale_factor_type sf, - ACE_UINT64 elapsed_time, - ACE_UINT32 samples_count) -{ -#ifndef ACE_NLOGGING - double seconds = - static_cast (ACE_UINT64_DBLCAST_ADAPTER (elapsed_time / sf)); - seconds /= ACE_HR_SCALE_CONVERSION; - - double t_avg = 0.0; - if (seconds > 0.0) - { - t_avg = samples_count / seconds; - } - - ACELIB_DEBUG ((LM_DEBUG, - ACE_TEXT ("%s throughput: %.2f (events/second)\n"), - msg, t_avg)); -#else - ACE_UNUSED_ARG (msg); - ACE_UNUSED_ARG (sf); - ACE_UNUSED_ARG (elapsed_time); - ACE_UNUSED_ARG (samples_count); -#endif /* ACE_NLOGGING */ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Throughput_Stats.h b/deps/acelite/ace/Throughput_Stats.h deleted file mode 100644 index f3d1744c5..000000000 --- a/deps/acelite/ace/Throughput_Stats.h +++ /dev/null @@ -1,72 +0,0 @@ -// -*- C++ -*- - -//========================================================================== -/** - * @file Throughput_Stats.h - * - * @author David L. Levine - */ -//========================================================================== - - -#ifndef ACE_THROUGHPUT_STATS_H -#define ACE_THROUGHPUT_STATS_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Basic_Stats.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/// A simple class to make throughput and latency analysis. -/** - * - * Keep the relevant information to perform throughput and latency - * analysis, including: - * -# Minimum, Average and Maximum latency - * -# Jitter for the latency - * -# Linear regression for throughput - * -# Accumulate results from several samples to obtain aggregated - * results, across several threads or experiments. - * - * @todo The idea behind this class was to use linear regression to - * determine if the throughput was linear or exhibited jitter. - * Unfortunately it never worked quite right, so only average - * throughput is computed. - */ -class ACE_Export ACE_Throughput_Stats : public ACE_Basic_Stats -{ -public: - /// Constructor - ACE_Throughput_Stats (void); - - /// Store one sample - void sample (ACE_UINT64 throughput, ACE_UINT64 latency); - - /// Update the values to reflect the stats in @a throughput - void accumulate (const ACE_Throughput_Stats &throughput); - - /// Print down the stats - void dump_results (const ACE_TCHAR* msg, scale_factor_type scale_factor); - - /// Dump the average throughput stats. - static void dump_throughput (const ACE_TCHAR *msg, - scale_factor_type scale_factor, - ACE_UINT64 elapsed_time, - ACE_UINT32 samples_count); -private: - /// The last throughput measurement. - ACE_UINT64 throughput_last_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#endif /* ! ACE_THROUGHPUT_STATS_H */ diff --git a/deps/acelite/ace/Time_Policy.cpp b/deps/acelite/ace/Time_Policy.cpp deleted file mode 100644 index 4d2e6880b..000000000 --- a/deps/acelite/ace/Time_Policy.cpp +++ /dev/null @@ -1,32 +0,0 @@ -#include "ace/Time_Policy.h" - -#if !defined(__ACE_INLINE__) -# include "ace/Time_Policy.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_Dynamic_Time_Policy_Base::~ACE_Dynamic_Time_Policy_Base () -{ -} - - -class NULL_Time_Policy : public ACE_Dynamic_Time_Policy_Base -{ -protected: - virtual ACE_Time_Value_T gettimeofday () const; -}; - -ACE_Time_Value_T NULL_Time_Policy::gettimeofday () const -{ - return ACE_Time_Value_T (ACE_Time_Value::zero); -} - -static NULL_Time_Policy null_policy_; - -ACE_Delegating_Time_Policy::ACE_Delegating_Time_Policy (ACE_Dynamic_Time_Policy_Base const * delegate) - : delegate_ (delegate != 0 ? delegate : &null_policy_) -{ -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Time_Policy.h b/deps/acelite/ace/Time_Policy.h deleted file mode 100644 index 29ffa7d4a..000000000 --- a/deps/acelite/ace/Time_Policy.h +++ /dev/null @@ -1,172 +0,0 @@ -#ifndef ACE_TIME_POLICY_H -#define ACE_TIME_POLICY_H -// -*- C++ -*- -/** - * @file Time_Policy.h - * - * @author Carlos O'Ryan - * @author Martin Corino - */ -#include /**/ "ace/pre.h" - -#include /**/ "ace/config-all.h" - -#include /**/ "ace/Time_Value_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_System_Time_Policy - * - * @brief Implement the system time policy for ACE. - * - * The most common time policy is to simply use - * ACE_OS::gettimeofday(), this class implements that policy, i.e., it - * simply calls that function. - */ -class ACE_Export ACE_System_Time_Policy -{ -public: - /// Return the current time according to this policy - ACE_Time_Value_T operator() () const; - - /// Noop. Just here to satisfy backwards compatibility demands. - void set_gettimeofday (ACE_Time_Value (*gettimeofday)(void)); -}; - -/** - * @class ACE_HR_Time_Policy - * - * @brief Implement a time policy based on the ACE Highres timer. - */ -class ACE_Export ACE_HR_Time_Policy -{ -public: - /// Return the current time according to this policy - ACE_Time_Value_T operator() () const; - - /// Noop. Just here to satisfy backwards compatibility demands. - void set_gettimeofday (ACE_Time_Value (*gettimeofday)(void)); -}; - -/** - * @class ACE_FPointer_Timer_Policy - * - * @brief Implement a time policy based on a function pointer. - * - * This time policy allows dynamic changes to the source of time by - * using a function pointer. - */ -class ACE_Export ACE_FPointer_Time_Policy -{ -public: - /** - * @brief Default constructor uses ACE_OS::gettimeofday() - * - * ACE_T requires a default constructor that leaves the - * policy in a functional state. Therefore, a null pointer would - * not be desirable, in other words, we need a non-trivial default - * constructor. - */ - ACE_FPointer_Time_Policy(); - - /** - * @typedef FPtr - * - * Short-hand for the right type of pointer to function. - */ - typedef ACE_Time_Value (*FPtr)(); - - /** - * @brief Constructor from a pointer to function. - * - * Construct from a pointer to function. - */ - ACE_FPointer_Time_Policy(FPtr f); - - /// Return the current time according to this policy - ACE_Time_Value_T operator()() const; - - /// Satisfy backwards compatibility demands. - void set_gettimeofday (ACE_Time_Value (*gettimeofday)(void)); -private: - FPtr function_; -}; - -class ACE_Dynamic_Time_Policy_Base; // forward decl - -/** - * @class ACE_Delegating_Time_Policy - * - * @brief Implement a time policy that delegates to a dynamic - * time policy. - */ -class ACE_Export ACE_Delegating_Time_Policy -{ -public: - ACE_Delegating_Time_Policy (ACE_Dynamic_Time_Policy_Base const * delegate = 0); - - /// Return the current time according to this policy - ACE_Time_Value_T operator()() const; - - /// Set delegate - void set_delegate (ACE_Dynamic_Time_Policy_Base const * delegate); - -#if defined (ACE_HAS_CPP11) - ACE_Delegating_Time_Policy (const ACE_Delegating_Time_Policy&) = default; - ACE_Delegating_Time_Policy (ACE_Delegating_Time_Policy&&) = default; - ACE_Delegating_Time_Policy& operator = (ACE_Delegating_Time_Policy const &) = default; - ACE_Delegating_Time_Policy &operator = (ACE_Delegating_Time_Policy&&) = default; -#endif /* ACE_HAS_CPP11 */ - - /// Noop. Just here to satisfy backwards compatibility demands. - void set_gettimeofday (ACE_Time_Value (*gettimeofday)(void)); -private: - ACE_Dynamic_Time_Policy_Base const * delegate_; -}; - -/** - * @class ACE_Dynamic_Time_Policy_base - * - * @brief Abstract base class for dynamically loaded and/or shared - * time policies. - */ -class ACE_Export ACE_Dynamic_Time_Policy_Base -{ -public: - virtual ~ACE_Dynamic_Time_Policy_Base (); - - /// Return the current time according to this policy - ACE_Time_Value_T operator()() const; - - /// Noop. Just here to satisfy backwards compatibility demands. - void set_gettimeofday (ACE_Time_Value (*gettimeofday)(void)); -protected: - /// Return the current time according to policy implementation. - virtual ACE_Time_Value_T gettimeofday () const = 0; -}; - -/// Temporarily, for backwards compatibility reasons, this will -/// be the default time policy. In time to be replaced by -/// ACE_System_Time_Policy. -typedef ACE_FPointer_Time_Policy ACE_Default_Time_Policy; - -#if defined ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION_EXPORT -template class ACE_Export ACE_Time_Value_T; -template class ACE_Export ACE_Time_Value_T; -template class ACE_Export ACE_Time_Value_T; -template class ACE_Export ACE_Time_Value_T; -#endif /* ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION_EXPORT */ - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (__ACE_INLINE__) -#include "ace/Time_Policy.inl" -#endif /* __ACE_INLINE__ */ - -#include /**/ "ace/post.h" -#endif /* ACE_TIME_POLICY_H */ diff --git a/deps/acelite/ace/Time_Policy.inl b/deps/acelite/ace/Time_Policy.inl deleted file mode 100644 index 8ecea8224..000000000 --- a/deps/acelite/ace/Time_Policy.inl +++ /dev/null @@ -1,85 +0,0 @@ -// -*- C++ -*- -#include "ace/OS_NS_sys_time.h" -#include "ace/High_Res_Timer.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -ACE_INLINE ACE_Time_Value_T -ACE_System_Time_Policy::operator()() const -{ - return ACE_Time_Value_T (ACE_OS::gettimeofday()); -} - -ACE_INLINE void -ACE_System_Time_Policy::set_gettimeofday (ACE_Time_Value (*)(void)) -{ -} - -ACE_INLINE ACE_Time_Value_T -ACE_HR_Time_Policy::operator()() const -{ - return ACE_Time_Value_T (ACE_High_Res_Timer::gettimeofday_hr ()); -} - -ACE_INLINE void -ACE_HR_Time_Policy::set_gettimeofday (ACE_Time_Value (*)(void)) -{ -} - -ACE_INLINE -ACE_FPointer_Time_Policy::ACE_FPointer_Time_Policy() - : function_(ACE_OS::gettimeofday) -{ -} - -ACE_INLINE -ACE_FPointer_Time_Policy:: -ACE_FPointer_Time_Policy(ACE_FPointer_Time_Policy::FPtr f) - : function_(f) -{ -} - -ACE_INLINE ACE_Time_Value_T -ACE_FPointer_Time_Policy::operator()() const -{ - return ACE_Time_Value_T ((*this->function_)(), *this); -} - -ACE_INLINE void -ACE_FPointer_Time_Policy::set_gettimeofday (ACE_Time_Value (*f)(void)) -{ - this->function_ = f; -} - -ACE_INLINE ACE_Time_Value_T -ACE_Dynamic_Time_Policy_Base::operator()() const -{ - return this->gettimeofday (); -} - -ACE_INLINE void -ACE_Dynamic_Time_Policy_Base::set_gettimeofday (ACE_Time_Value (*)(void)) -{ -} - -ACE_INLINE ACE_Time_Value_T -ACE_Delegating_Time_Policy::operator()() const -{ - return (*this->delegate_) (); -} - -ACE_INLINE void -ACE_Delegating_Time_Policy::set_gettimeofday (ACE_Time_Value (*)(void)) -{ -} - -ACE_INLINE void -ACE_Delegating_Time_Policy::set_delegate (ACE_Dynamic_Time_Policy_Base const * delegate) -{ - if (delegate != 0) - { - this->delegate_ = delegate; - } -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Time_Policy_T.cpp b/deps/acelite/ace/Time_Policy_T.cpp deleted file mode 100644 index 4ca20433e..000000000 --- a/deps/acelite/ace/Time_Policy_T.cpp +++ /dev/null @@ -1,25 +0,0 @@ -#ifndef ACE_TIME_POLICY_T_CPP -#define ACE_TIME_POLICY_T_CPP - -#include "ace/Time_Policy_T.h" - -#if !defined (__ACE_INLINE__) -#include "ace/Time_Policy_T.inl" -#endif /* __ACE_INLINE__ */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Time_Policy_T::~ACE_Time_Policy_T () -{ -} - -template ACE_Time_Value_T -ACE_Time_Policy_T::gettimeofday () const -{ - return ACE_Time_Value_T (this->time_policy_ (), ACE_Delegating_Time_Policy (this)); -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_TIME_POLICY_T_CPP */ diff --git a/deps/acelite/ace/Time_Policy_T.h b/deps/acelite/ace/Time_Policy_T.h deleted file mode 100644 index 85d0dde6a..000000000 --- a/deps/acelite/ace/Time_Policy_T.h +++ /dev/null @@ -1,74 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Time_Policy_T.h - * - * @author Martin Corino - */ -//============================================================================= - -#ifndef ACE_TIME_POLICY_T_H -#define ACE_TIME_POLICY_T_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Time_Policy.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Time_Policy_T - * - * @brief Template class implementing a dynamic time policy based on - * another time policy - */ -template -class ACE_Time_Policy_T : public ACE_Dynamic_Time_Policy_Base -{ -public: - ACE_Time_Policy_T (TIME_POLICY const & time_policy = TIME_POLICY()); - virtual ~ACE_Time_Policy_T (); - - /// Return the current time according to this policy - ACE_Time_Value_T operator()() const; - - /// Allows applications to control how the timer queue gets the time - /// of day. - void set_time_policy(TIME_POLICY const & time_policy); - - /// Noop. Just here to satisfy backwards compatibility demands. - void set_gettimeofday (ACE_Time_Value (*gettimeofday)(void)); -protected: - /// Return the current time according to policy implementation. - virtual ACE_Time_Value_T gettimeofday () const; - -private: - /// The policy to return the current time of day - TIME_POLICY time_policy_; -}; - -ACE_END_VERSIONED_NAMESPACE_DECL - -#include /**/ "ace/post.h" - -#if defined (__ACE_INLINE__) -#include "ace/Time_Policy_T.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) -#include "ace/Time_Policy_T.cpp" -#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ - -#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) -#pragma implementation ("Time_Policy_T.cpp") -#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ - - -#endif /* ACE_TIME_POLICY_T_H */ diff --git a/deps/acelite/ace/Time_Policy_T.inl b/deps/acelite/ace/Time_Policy_T.inl deleted file mode 100644 index 25a5ea079..000000000 --- a/deps/acelite/ace/Time_Policy_T.inl +++ /dev/null @@ -1,29 +0,0 @@ -// -*- C++ -*- -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_INLINE -ACE_Time_Policy_T::ACE_Time_Policy_T (TIME_POLICY const & time_policy) - : time_policy_ (time_policy) -{ -} - -template -ACE_INLINE ACE_Time_Value_T -ACE_Time_Policy_T::operator() () const -{ - return this->gettimeofday (); -} - -template ACE_INLINE void -ACE_Time_Policy_T::set_gettimeofday (ACE_Time_Value (*)(void)) -{ -} - -template ACE_INLINE void -ACE_Time_Policy_T::set_time_policy(TIME_POLICY const & time_policy) -{ - this->time_policy_ = time_policy; -} - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Time_Value.cpp b/deps/acelite/ace/Time_Value.cpp deleted file mode 100644 index 77c151e13..000000000 --- a/deps/acelite/ace/Time_Value.cpp +++ /dev/null @@ -1,347 +0,0 @@ -#include "ace/Time_Value.h" - -#if defined (ACE_HAS_ALLOC_HOOKS) -# include "ace/Malloc_Base.h" -#endif /* ACE_HAS_ALLOC_HOOKS */ - -#if !defined (__ACE_INLINE__) -#include "ace/Time_Value.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/Numeric_Limits.h" -#include "ace/If_Then_Else.h" -#include "ace/OS_NS_math.h" -#include "ace/Time_Policy.h" - -#ifdef ACE_HAS_CPP98_IOSTREAMS -# include -# include -#endif /* ACE_HAS_CPP98_IOSTREAMS */ - -#include - -#ifdef ACE_HAS_CPP11 -# include -#endif /* ACE_HAS_CPP11 */ - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/// Static constant representing `zero-time'. -/// Note: this object requires static construction. -const ACE_Time_Value ACE_Time_Value::zero; - -/// Constant for maximum time representable. Note that this time -/// is not intended for use with select () or other calls that may -/// have *their own* implementation-specific maximum time representations. -/// Its primary use is in time computations such as those used by the -/// dynamic subpriority strategies in the ACE_Dynamic_Message_Queue class. -/// Note: this object requires static construction. -const ACE_Time_Value ACE_Time_Value::max_time ( - ACE_Numeric_Limits::max (), - ACE_ONE_SECOND_IN_USECS - 1); - -ACE_ALLOC_HOOK_DEFINE (ACE_Time_Value) - -ACE_Time_Value::~ACE_Time_Value() -{} - -/// Increment microseconds (the only reason this is here is to allow -/// the use of ACE_Atomic_Op with ACE_Time_Value). -ACE_Time_Value -ACE_Time_Value::operator ++ (int) -{ - // ACE_OS_TRACE ("ACE_Time_Value::operator ++ (int)"); - ACE_Time_Value tv (*this); - ++*this; - return tv; -} - -ACE_Time_Value & -ACE_Time_Value::operator ++ (void) -{ - // ACE_OS_TRACE ("ACE_Time_Value::operator ++ (void)"); - this->usec (this->usec () + 1); - this->normalize (); - return *this; -} - -/// Decrement microseconds (the only reason this is here is / to allow -/// the use of ACE_Atomic_Op with ACE_Time_Value). -ACE_Time_Value -ACE_Time_Value::operator -- (int) -{ - // ACE_OS_TRACE ("ACE_Time_Value::operator -- (int)"); - ACE_Time_Value tv (*this); - --*this; - return tv; -} - -ACE_Time_Value & -ACE_Time_Value::operator -- (void) -{ - // ACE_OS_TRACE ("ACE_Time_Value::operator -- (void)"); - this->usec (this->usec () - 1); - this->normalize (); - return *this; -} - -#if defined (ACE_WIN32) -/// Static constant to remove time skew between FILETIME and POSIX -/// time. POSIX and Win32 use different epochs (Jan. 1, 1970 v.s. -/// Jan. 1, 1601). The following constant defines the difference -/// in 100ns ticks. -/// -/// In the beginning (Jan. 1, 1601), there was no time and no computer. -/// And Bill said: "Let there be time," and there was time.... -const DWORDLONG ACE_Time_Value::FILETIME_to_timval_skew = -ACE_INT64_LITERAL (0x19db1ded53e8000); - -/// Initializes the ACE_Time_Value object from a Win32 FILETIME -ACE_Time_Value::ACE_Time_Value (const FILETIME &file_time) -{ - // // ACE_OS_TRACE ("ACE_Time_Value::ACE_Time_Value"); - this->set (file_time); -} - -void ACE_Time_Value::set (const FILETIME &file_time) -{ - // Initializes the ACE_Time_Value object from a Win32 FILETIME - // Don't use a struct initializer, gcc don't like it. - ULARGE_INTEGER _100ns; - _100ns.LowPart = file_time.dwLowDateTime; - _100ns.HighPart = file_time.dwHighDateTime; - - _100ns.QuadPart -= ACE_Time_Value::FILETIME_to_timval_skew; - - // Convert 100ns units to seconds; - this->tv_.tv_sec = (time_t) (_100ns.QuadPart / (10000 * 1000)); - // Convert remainder to microseconds; - this->tv_.tv_usec = (suseconds_t) ((_100ns.QuadPart % (10000 * 1000)) / 10); - - this->normalize (); -} - -/// Returns the value of the object as a Win32 FILETIME. -ACE_Time_Value::operator FILETIME () const -{ - FILETIME file_time; - // ACE_OS_TRACE ("ACE_Time_Value::operator FILETIME"); - - ULARGE_INTEGER _100ns; - _100ns.QuadPart = (((DWORDLONG) this->tv_.tv_sec * (10000 * 1000) + - this->tv_.tv_usec * 10) + - ACE_Time_Value::FILETIME_to_timval_skew); - - file_time.dwLowDateTime = _100ns.LowPart; - file_time.dwHighDateTime = _100ns.HighPart; - - return file_time; -} -#endif /* ACE_WIN32 */ - -ACE_Time_Value -ACE_Time_Value::now () const -{ - ACE_System_Time_Policy systp; - return systp (); -} - -ACE_Time_Value -ACE_Time_Value::to_relative_time () const -{ - ACE_System_Time_Policy systp; - return (*this) - systp (); -} - -ACE_Time_Value -ACE_Time_Value::to_absolute_time () const -{ - ACE_System_Time_Policy systp; - return (*this) + systp (); -} - -ACE_Time_Value * -ACE_Time_Value::duplicate () const -{ - ACE_Time_Value * tmp = 0; - ACE_NEW_RETURN (tmp, ACE_Time_Value (*this), 0); - return tmp; -} - -void -ACE_Time_Value::dump (void) const -{ -} - -void -ACE_Time_Value::normalize (bool saturate) -{ - // ACE_OS_TRACE ("ACE_Time_Value::normalize"); - if (this->tv_.tv_usec >= ACE_ONE_SECOND_IN_USECS || - this->tv_.tv_usec <= -ACE_ONE_SECOND_IN_USECS) - { - time_t const sec = std::abs(this->tv_.tv_usec) / ACE_ONE_SECOND_IN_USECS * (this->tv_.tv_usec > 0 ? 1 : -1); - suseconds_t const usec = static_cast (this->tv_.tv_usec - sec * ACE_ONE_SECOND_IN_USECS); - - if (saturate && this->tv_.tv_sec > 0 && sec > 0 && - ACE_Numeric_Limits::max() - this->tv_.tv_sec < sec) - { - this->tv_.tv_sec = ACE_Numeric_Limits::max(); - this->tv_.tv_usec = ACE_ONE_SECOND_IN_USECS - 1; - } - else if (saturate && this->tv_.tv_sec < 0 && sec < 0 && - ACE_Numeric_Limits::min() - this->tv_.tv_sec > sec) - { - this->tv_.tv_sec = ACE_Numeric_Limits::min(); - this->tv_.tv_usec = -ACE_ONE_SECOND_IN_USECS + 1; - } - else - { - this->tv_.tv_sec += sec; - this->tv_.tv_usec = usec; - } - } - - if (this->tv_.tv_sec >= 1 && this->tv_.tv_usec < 0) - { - --this->tv_.tv_sec; - this->tv_.tv_usec += ACE_ONE_SECOND_IN_USECS; - } - // tv_sec in qnxnto is unsigned -#if !defined ( __QNX__) - else if (this->tv_.tv_sec < 0 && this->tv_.tv_usec > 0) - { - ++this->tv_.tv_sec; - this->tv_.tv_usec -= ACE_ONE_SECOND_IN_USECS; - } -#endif /* __QNX__ */ -} - - -ACE_Time_Value & -ACE_Time_Value::operator *= (double d) -{ - // To work around the lack of precision of a long double to contain - // a 64-bits time_t + 6 digits after the decimal point for the usec part, - // we perform the multiplication of the 2 timeval parts separately. - // - // This extra precision step is adding a cost when transfering the - // seconds resulting from the usec multiplication. This operation - // correspond to the normalization process performed in normalize() - // but we must absolutly do it here because the usec multiplication - // result value could exceed what can be stored in a suseconds_t - // type variable. - // - // Since this is a costly operation, we try to detect as soon as - // possible if we are having a saturation in order to abort the rest - // of the computation. - typedef ACE::If_Then_Else<(sizeof (double) > sizeof (time_t)), - double, - long double>::result_type float_type; - - float_type sec_total = static_cast (this->sec()); - sec_total *= d; - - // shall we saturate the result? - static const float_type max_int = - ACE_Numeric_Limits::max() + 0.999999; - static const float_type min_int = - ACE_Numeric_Limits::min() - 0.999999; - - if (sec_total > max_int) - { - this->set(ACE_Numeric_Limits::max(), ACE_ONE_SECOND_IN_USECS-1); - } - else if (sec_total < min_int) - { - this->set(ACE_Numeric_Limits::min(), -ACE_ONE_SECOND_IN_USECS+1); - } - else - { - time_t time_sec = static_cast (sec_total); - - float_type usec_total = this->usec(); - usec_total *= d; - - // adding usec resulting from tv_sec mult - usec_total += (sec_total-time_sec) * ACE_ONE_SECOND_IN_USECS; - - // extract seconds component of the usec mult - sec_total = usec_total / ACE_ONE_SECOND_IN_USECS; - // keep remaining usec - if (sec_total > 0) - { - usec_total = (sec_total - ACE_OS::floor(sec_total)); - } - else - { - usec_total = (sec_total - ACE_OS::ceil(sec_total)); - } - - sec_total -= usec_total; - usec_total *= ACE_ONE_SECOND_IN_USECS; - - // add the seconds component of the usec mult with the tv_sec mult prod. - sec_total += time_sec; - - // recheck for saturation - if (sec_total > max_int) - { - this->set (ACE_Numeric_Limits::max(), ACE_ONE_SECOND_IN_USECS - 1); - } - else if (sec_total < min_int) - { - this->set (ACE_Numeric_Limits::min(), -ACE_ONE_SECOND_IN_USECS + 1); - } - else - { - time_sec = static_cast (sec_total); - suseconds_t time_usec = static_cast (usec_total); - - // round up the result to save the last usec - if (time_usec > 0 && (usec_total - time_usec) >= 0.5) - { - ++time_usec; - } - else if (time_usec < 0 && (usec_total - time_usec) <= -0.5) - { - --time_usec; - } - - this->set (time_sec, time_usec); - } - } - return *this; -} - -#ifdef ACE_HAS_CPP98_IOSTREAMS -ostream &operator<<(ostream &o, const ACE_Time_Value &v) -{ - char const oldFiller = o.fill (); - o.fill ('0'); - const timeval *tv = v; - if (tv->tv_sec) - { - o << tv->tv_sec; - if (tv->tv_usec) -#ifdef ACE_HAS_CPP11 - o << '.' << std::setw (6) << std::labs (tv->tv_usec); -#else - o << '.' << std::setw (6) << ACE_STD_NAMESPACE::labs (tv->tv_usec); -#endif - } - else if (tv->tv_usec < 0) - o << "-0." << std::setw (6) << - tv->tv_usec; - else - { - o << '0'; - if (tv->tv_usec > 0) - o << '.'<< std::setw (6) << tv->tv_usec; - } - - o.fill (oldFiller); - return o; -} -#endif /* ACE_HAS_CPP98_IOSTREAMS */ - -ACE_END_VERSIONED_NAMESPACE_DECL diff --git a/deps/acelite/ace/Time_Value.h b/deps/acelite/ace/Time_Value.h deleted file mode 100644 index 4c295c739..000000000 --- a/deps/acelite/ace/Time_Value.h +++ /dev/null @@ -1,557 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Time_Value.h - * - * @author Douglas C. Schmidt - */ -//============================================================================= - -#ifndef ACE_TIME_VALUE_H -#define ACE_TIME_VALUE_H - -#include /**/ "ace/pre.h" - -#include /**/ "ace/ACE_export.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -# include "ace/os_include/os_time.h" - -#if defined (ACE_HAS_CPP11) -# include -# include "ace/Truncate.h" -#endif /* ACE_HAS_CPP11 */ - -// Define some helpful constants. -// Not type-safe, and signed. For backward compatibility. -#define ACE_ONE_SECOND_IN_MSECS 1000L -suseconds_t const ACE_ONE_SECOND_IN_USECS = 1000000; -#define ACE_ONE_SECOND_IN_NSECS 1000000000L - -// needed for ACE_UINT64 -#include "ace/Basic_Types.h" - -// needed to determine if iostreams are present -#include "ace/iosfwd.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Time_Value - * - * @brief Operations on "timeval" structures, which express time in - * seconds (secs) and microseconds (usecs). - * - * This class centralizes all the time related processing in - * ACE. These time values are typically used in conjunction with OS - * mechanisms like or other calls that may have - * *their own* implementation-specific maximum time representations. - * Its primary use is in time computations such as those used by the - * dynamic subpriority strategies in the ACE_Dynamic_Message_Queue - * class. - */ - static const ACE_Time_Value max_time; - - /// Default Constructor. - ACE_Time_Value (void); - - /// Constructor. - explicit ACE_Time_Value (time_t sec, suseconds_t usec = 0); - - // = Methods for converting to/from various time formats. - - /// Construct the ACE_Time_Value from a timeval. - explicit ACE_Time_Value (const struct timeval &t); - - /// Construct the ACE_Time_Value object from a timespec_t. - explicit ACE_Time_Value (const timespec_t &t); - -#if defined (ACE_HAS_CPP11) - ACE_Time_Value (const ACE_Time_Value&) = default; - ACE_Time_Value (ACE_Time_Value&&) = default; - - /// Construct the ACE_Time_Value object from a chrono duration. - template< class Rep, class Period > - explicit ACE_Time_Value (const std::chrono::duration& duration) - { - this->set (duration); - } -#endif /* ACE_HAS_CPP11 */ - - /// Destructor - virtual ~ACE_Time_Value (); - - /// Declare the dynamic allocation hooks. - ACE_ALLOC_HOOK_DECLARE; - -# if defined (ACE_WIN32) - /// Construct the ACE_Time_Value object from a Win32 FILETIME - explicit ACE_Time_Value (const FILETIME &ft); -# endif /* ACE_WIN32 */ - - /// Initializes the ACE_Time_Value from seconds and useconds. - void set (time_t sec, suseconds_t usec); - - /// Initializes the ACE_Time_Value from a double, which is assumed to be - /// in second format, with any remainder treated as microseconds. - void set (double d); - - /// Initializes the ACE_Time_Value from a timeval. - void set (const timeval &t); - - /// Initializes the ACE_Time_Value object from a timespec_t. - void set (const timespec_t &t); - -# if defined (ACE_WIN32) - /// Initializes the ACE_Time_Value object from a Win32 FILETIME. - void set (const FILETIME &ft); -# endif /* ACE_WIN32 */ - -#if defined (ACE_HAS_CPP11) - /// Initializes the ACE_Time_Value object from a std::duration. - template< class Rep, class Period > - void set (const std::chrono::duration& duration) - { - std::chrono::seconds const s { - std::chrono::duration_cast (duration)}; - - std::chrono::microseconds const usec { - std::chrono::duration_cast( - duration % std::chrono::seconds (1))}; - this->set (s.count (), ACE_Utils::truncate_cast(usec.count ())); - } -#endif /* ACE_HAS_CPP11 */ - - /// Converts from ACE_Time_Value format into milliseconds format. - /** - * @return Sum of second field (in milliseconds) and microsecond field - * (in milliseconds). Note that this method can overflow if - * the second and microsecond field values are large, so use - * the msec (ACE_UINT64 &ms) method instead. - * - * @note The semantics of this method differs from the sec() and - * usec() methods. There is no analogous "millisecond" - * component in an ACE_Time_Value. - */ - unsigned long msec (void) const; - - /// Converts from ACE_Time_Value format into milliseconds format. - /** - * @return Sum of second field (in milliseconds) and microsecond field - * (in milliseconds). - * - * @note The semantics of this method differs from the sec() and - * usec() methods. There is no analogous "millisecond" - * component in an ACE_Time_Value. - */ - ACE_UINT64 get_msec () const; - - /// Converts from ACE_Time_Value format into milliseconds format. - /** - * @return Sum of second field (in milliseconds) and microsecond field - * (in milliseconds) and return them via the @param ms parameter. - * - * @note The semantics of this method differs from the sec() and - * usec() methods. There is no analogous "millisecond" - * component in an ACE_Time_Value. - * - * @deprecated Use get_msec() instead. - */ - void msec (ACE_UINT64 &ms) const; - - /// Converts from ACE_Time_Value format into milliseconds format. - /** - * @return Sum of second field (in milliseconds) and microsecond field - * (in milliseconds) and return them via the @param ms parameter. - * - * @note The semantics of this method differs from the sec() and - * usec() methods. There is no analogous "millisecond" - * component in an ACE_Time_Value. - * - * @deprecated Use get_msec() instead. - */ - void msec (ACE_UINT64 &ms) /* const */; - - /// Converts from milli-seconds format into ACE_Time_Value format. - /** - * @note The semantics of this method differs from the sec() and - * usec() methods. There is no analogous "millisecond" - * component in an ACE_Time_Value. - */ - void set_msec (const ACE_UINT64 &ms); - - /// Converts from milli-seconds format into ACE_Time_Value format. - /** - * @note The semantics of this method differs from the sec() and - * usec() methods. There is no analogous "millisecond" - * component in an ACE_Time_Value. - */ - void msec (long); - - /// Converts from milli-seconds format into ACE_Time_Value format. - /** - * @note The semantics of this method differs from the sec() and - * usec() methods. There is no analogous "millisecond" - * component in an ACE_Time_Value. - */ - void msec (int); // converted to long then calls above. - - /// Returns the value of the object as a timespec_t. - operator timespec_t () const; - - /// Returns the value of the object as a timeval. - operator timeval () const; - - /// Returns a pointer to the object as a timeval. - operator const timeval *() const; - -# if defined (ACE_WIN32) - /// Returns the value of the object as a Win32 FILETIME. - operator FILETIME () const; -# endif /* ACE_WIN32 */ - - // = The following are accessor/mutator methods. - - /// Get seconds. - /** - * @return The second field/component of this ACE_Time_Value. - * - * @note The semantics of this method differs from the msec() - * method. - */ - time_t sec (void) const; - - /// Set seconds. - void sec (time_t sec); - - /// Get microseconds. - /** - * @return The microsecond field/component of this ACE_Time_Value. - * - * @note The semantics of this method differs from the msec() - * method. - */ - suseconds_t usec (void) const; - - /// Set microseconds. - void usec (suseconds_t usec); - - /** - * @return Sum of second field (in microseconds) and microsecond field - * and return them via the @param usec parameter. - */ - void to_usec (ACE_UINT64 &usec) const; - - // = The following arithmetic methods operate on ACE_Time_Value's. - - /// Add @a tv to this. - ACE_Time_Value &operator += (const ACE_Time_Value &tv); - - /// Add @a tv to this. - ACE_Time_Value &operator += (time_t tv); - -#if defined (ACE_HAS_CPP11) - /// Assign @a tv to this - ACE_Time_Value &operator = (const ACE_Time_Value &) = default; - ACE_Time_Value &operator = (ACE_Time_Value &&) = default; -#endif /* ACE_HAS_CPP11 */ - - /// Assign @a tv to this - ACE_Time_Value &operator = (time_t tv); - - /// Subtract @a tv to this. - ACE_Time_Value &operator -= (const ACE_Time_Value &tv); - - /// Subtract @a tv to this. - ACE_Time_Value &operator -= (time_t tv); - -#if defined (ACE_HAS_CPP11) - /// Add @a std::duration to this. - template< class Rep, class Period > - ACE_Time_Value &operator += (const std::chrono::duration& duration) - { - const ACE_Time_Value tv (duration); - this->sec (this->sec () + tv.sec ()); - this->usec (this->usec () + tv.usec ()); - this->normalize (); - return *this; - } - - /// Assign @a std::duration to this - template< class Rep, class Period > - ACE_Time_Value &operator = (const std::chrono::duration& duration) - { - this->set (duration); - return *this; - } - - /// Subtract @a std::duration to this. - template< class Rep, class Period > - ACE_Time_Value &operator -= (const std::chrono::duration& duration) - { - const ACE_Time_Value tv (duration); - this->sec (this->sec () - tv.sec ()); - this->usec (this->usec () - tv.usec ()); - this->normalize (); - return *this; - } -#endif /* ACE_HAS_CPP11 */ - - - /** - \brief Multiply the time value by the @a d factor. - \note The result of the operator is valid for results from range - < (ACE_INT32_MIN, -999999), (ACE_INT32_MAX, 999999) >. Result - outside this range are saturated to a limit. - */ - ACE_Time_Value &operator *= (double d); - - /// Increment microseconds as postfix. - /** - * @note The only reason this is here is to allow the use of ACE_Atomic_Op - * with ACE_Time_Value. - */ - ACE_Time_Value operator++ (int); - - /// Increment microseconds as prefix. - /** - * @note The only reason this is here is to allow the use of ACE_Atomic_Op - * with ACE_Time_Value. - */ - ACE_Time_Value &operator++ (void); - - /// Decrement microseconds as postfix. - /** - * @note The only reason this is here is to allow the use of ACE_Atomic_Op - * with ACE_Time_Value. - */ - ACE_Time_Value operator-- (int); - - /// Decrement microseconds as prefix. - /** - * @note The only reason this is here is to allow the use of ACE_Atomic_Op - * with ACE_Time_Value. - */ - ACE_Time_Value &operator-- (void); - - /// Adds two ACE_Time_Value objects together, returns the sum. - friend ACE_Export ACE_Time_Value operator + (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2); - - /// Subtracts two ACE_Time_Value objects, returns the difference. - friend ACE_Export ACE_Time_Value operator - (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2); - - /// True if @a tv1 < @a tv2. - friend ACE_Export bool operator < (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2); - - /// True if @a tv1 > @a tv2. - friend ACE_Export bool operator > (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2); - - /// True if @a tv1 <= @a tv2. - friend ACE_Export bool operator <= (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2); - - /// True if @a tv1 >= @a tv2. - friend ACE_Export bool operator >= (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2); - - /// True if @a tv1 == @a tv2. - friend ACE_Export bool operator == (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2); - - /// True if @a tv1 != @a tv2. - friend ACE_Export bool operator != (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2); - - //@{ - /// Multiplies the time value by @a d - friend ACE_Export ACE_Time_Value operator * (double d, - const ACE_Time_Value &tv); - - friend ACE_Export ACE_Time_Value operator * (const ACE_Time_Value &tv, - double d); - //@} - - /// Get current time of day. - /** - * @return Time value representing current time of day. - * - * @note This method is overloaded in the time policy based template - * instantiations derived from this class. Allows for time policy - * aware time values. - */ - virtual ACE_Time_Value now () const; - - /// Converts absolute time value to time value relative to current time of day. - /** - * @return Relative time value. - * - * @note This method is overloaded in the time policy based template - * instantiations derived from this class. Allows for time policy - * aware time values. - * The developer is responsible for making sure this is an absolute - * time value compatible with the active time policy (which is system - * time for the base class). - */ - virtual ACE_Time_Value to_relative_time () const; - - /// Converts relative time value to absolute time value based on current time of day. - /** - * @return Absolute time value. - * - * @note This method is overloaded in the time policy based template - * instantiations derived from this class. Allows for time policy - * aware time values. - * The developer is responsible for making sure this is a relative - * time value. Current time of day is determined based on time policy - * (which is system time for the base class). - */ - virtual ACE_Time_Value to_absolute_time () const; - - /// Duplicates this time value (incl. time policy). - /** - * @return Dynamically allocated time value copy. - * - * @note The caller is responsible for freeing the copy when it's not needed - * anymore. - */ - virtual ACE_Time_Value * duplicate () const; - - /// Dump is a no-op. - /** - * The dump() method is a no-op. It's here for backwards compatibility - * only, but does not dump anything. Invoking logging methods here - * violates layering restrictions in ACE because this class is part - * of the OS layer and @c ACE_Log_Msg is at a higher level. - */ - void dump (void) const; - -# if defined (ACE_WIN32) - /// Const time difference between FILETIME and POSIX time. - static const DWORDLONG FILETIME_to_timval_skew; -# endif /* ACE_WIN32 */ - -private: - /// Put the timevalue into a canonical form. - void normalize (bool saturate = false); - - /// Store the values as a timeval. -#if defined (ACE_HAS_TIME_T_LONG_MISMATCH) - // Windows' timeval is non-conformant, so swap in a struct that conforms - // to the proper data types to represent the entire time range that this - // class's API can accept. - // Also, since this class can supply a pointer to a timeval that things - // like select() expect, we need the OS-defined one as well. To make this - // available, use a real timeval called ext_tv_ and set it up when needed. - // Since this is most often for relative times that don't approach 32 bits - // in size, reducing a time_t to fit should be no problem. - struct { - time_t tv_sec; - suseconds_t tv_usec; - } tv_; - timeval ext_tv_; -#else - timeval tv_; -#endif /* ACE_HAS_TIME_T_LONG_MISMATCH */ -}; - -#ifdef ACE_HAS_CPP98_IOSTREAMS -extern ACE_Export ostream &operator<<( ostream &o, const ACE_Time_Value &v ); -#endif - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_HAS_CPP11) - -// Additional chrono operators. - -namespace std -{ - namespace chrono - { - /** - * @name Streaming ACE_Time_Value to chrono - * - * Streaming an ACE_Time_Value into one of the chrono types (nanoseconds, - * microseconds, milliseconds, seconds, minutes, or hours). - * - */ - //@{ - ACE_Export nanoseconds& operator <<(nanoseconds &ns, ACE_Time_Value const &tv); - ACE_Export microseconds& operator <<(microseconds &us, ACE_Time_Value const &tv); - ACE_Export milliseconds& operator <<(milliseconds &ms, ACE_Time_Value const &tv); - ACE_Export seconds& operator <<(seconds &s, ACE_Time_Value const &tv); - ACE_Export minutes& operator <<(minutes &m, ACE_Time_Value const &tv); - ACE_Export hours& operator <<(hours &h, ACE_Time_Value const &tv); - //@} - - /** - * @name Adding ACE_Time_Value to chrono - * - * Adding an ACE_Time_Value to one of the chrono types (nanoseconds, - * microseconds, milliseconds, seconds, minutes, or hours). - * - */ - //@{ - ACE_Export nanoseconds& operator +=(nanoseconds &ns, ACE_Time_Value const &tv); - ACE_Export microseconds& operator +=(microseconds &us, ACE_Time_Value const &tv); - ACE_Export milliseconds& operator +=(milliseconds &ms, ACE_Time_Value const &tv); - ACE_Export seconds& operator +=(seconds &s, ACE_Time_Value const &tv); - ACE_Export minutes& operator +=(minutes &m, ACE_Time_Value const &tv); - ACE_Export hours& operator +=(hours &h, ACE_Time_Value const &tv); - //@} - - /** - * @name Substracting ACE_Time_Value from chrono - * - * Substracting an ACE_Time_Value from one of the chrono types (nanoseconds, - * microseconds, milliseconds, seconds, minutes, or hours). - * - */ - //@{ - ACE_Export nanoseconds& operator -=(nanoseconds &ns, ACE_Time_Value const &tv); - ACE_Export microseconds& operator -=(microseconds &us, ACE_Time_Value const &tv); - ACE_Export milliseconds& operator -=(milliseconds &ms, ACE_Time_Value const &tv); - ACE_Export seconds& operator -=(seconds &s, ACE_Time_Value const &tv); - ACE_Export minutes& operator -=(minutes &m, ACE_Time_Value const &tv); - ACE_Export hours& operator -=(hours &h, ACE_Time_Value const &tv); - //@} - } -} - -#endif /* ACE_HAS_CPP11 */ - -#if defined (__ACE_INLINE__) -#include "ace/Time_Value.inl" -#endif /* __ACE_INLINE__ */ - -#if defined (__MINGW32__) -ACE_BEGIN_VERSIONED_NAMESPACE_DECL -// The MingW linker has problems with the exported statics -// zero and max_time with these two statics the linker will be able to -// resolve the static exported symbols. -static const ACE_Time_Value& __zero_time = ACE_Time_Value::zero; -static const ACE_Time_Value& __max_time = ACE_Time_Value::max_time; -ACE_END_VERSIONED_NAMESPACE_DECL -#endif /* __MINGW32__ */ - -#include /**/ "ace/post.h" - -#endif /* ACE_TIME_VALUE_H */ diff --git a/deps/acelite/ace/Time_Value.inl b/deps/acelite/ace/Time_Value.inl deleted file mode 100644 index 581e34865..000000000 --- a/deps/acelite/ace/Time_Value.inl +++ /dev/null @@ -1,556 +0,0 @@ -// -*- C++ -*- -#include "ace/Truncate.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/// Returns the value of the object as a timeval. -ACE_INLINE -ACE_Time_Value::operator timeval () const -{ - // ACE_OS_TRACE ("ACE_Time_Value::operator timeval"); -#if defined (ACE_HAS_TIME_T_LONG_MISMATCH) - // Recall that on some Windows we substitute another type for timeval in tv_ - ACE_Time_Value *me = const_cast (this); - me->ext_tv_.tv_sec = ACE_Utils::truncate_cast (this->tv_.tv_sec); - me->ext_tv_.tv_usec = ACE_Utils::truncate_cast (this->tv_.tv_usec); - return this->ext_tv_; -#else - return this->tv_; -#endif /* ACE_HAS_TIME_T_LONG_MISMATCH */ -} - -ACE_INLINE void -ACE_Time_Value::set (const timeval &tv) -{ - // ACE_OS_TRACE ("ACE_Time_Value::set"); - this->tv_.tv_sec = tv.tv_sec; - this->tv_.tv_usec = tv.tv_usec; - - this->normalize (); -} - -ACE_INLINE -ACE_Time_Value::ACE_Time_Value (const struct timeval &tv) -{ - // ACE_OS_TRACE ("ACE_Time_Value::ACE_Time_Value"); - this->set (tv); -} - -ACE_INLINE -ACE_Time_Value::operator const timeval * () const -{ - // ACE_OS_TRACE ("ACE_Time_Value::operator const timeval *"); -#if defined (ACE_HAS_TIME_T_LONG_MISMATCH) - // Recall that on some Windows we substitute another type for timeval in tv_ - ACE_Time_Value *me = const_cast (this); - me->ext_tv_.tv_sec = ACE_Utils::truncate_cast (this->tv_.tv_sec); - me->ext_tv_.tv_usec = ACE_Utils::truncate_cast (this->tv_.tv_usec); - return (const timeval *) &this->ext_tv_; -#else - return (const timeval *) &this->tv_; -#endif /* ACE_HAS_TIME_T_LONG_MISMATCH */ -} - -ACE_INLINE void -ACE_Time_Value::set (time_t sec, suseconds_t usec) -{ - // ACE_OS_TRACE ("ACE_Time_Value::set"); - this->tv_.tv_sec = sec; - this->tv_.tv_usec = usec; -#if __GNUC__ && !(__GNUC__ == 3 && __GNUC_MINOR__ == 4) - if ((__builtin_constant_p(sec) & - __builtin_constant_p(usec)) && - (sec >= 0 && usec >= 0 && usec < ACE_ONE_SECOND_IN_USECS)) - return; -#endif - this->normalize (); -} - -ACE_INLINE void -ACE_Time_Value::set (double d) -{ - // ACE_OS_TRACE ("ACE_Time_Value::set"); - if (d < ACE_Numeric_Limits::min()) - { - this->tv_.tv_sec = ACE_Numeric_Limits::min(); - this->tv_.tv_usec = -ACE_ONE_SECOND_IN_USECS + 1; - } - else if (d > ACE_Numeric_Limits::max()) - { - this->tv_.tv_sec = ACE_Numeric_Limits::max(); - this->tv_.tv_usec = ACE_ONE_SECOND_IN_USECS - 1; - } - else - { - time_t l = (time_t) d; - this->tv_.tv_sec = l; - this->tv_.tv_usec = (suseconds_t) ((d - (double) l) * ACE_ONE_SECOND_IN_USECS + (d < 0 ? -0.5 : 0.5)); - } -} - -/// Initializes a timespec_t. Note that this approach loses precision -/// since it converts the nano-seconds into micro-seconds. But then -/// again, do any real systems have nano-second timer precision?! -ACE_INLINE void -ACE_Time_Value::set (const timespec_t &tv) -{ - // ACE_OS_TRACE ("ACE_Time_Value::set"); - - this->set (tv.tv_sec, - tv.tv_nsec / 1000); // Convert nanoseconds into microseconds. -} - -ACE_INLINE -ACE_Time_Value::ACE_Time_Value (void) - // : tv_ () -{ - // ACE_OS_TRACE ("ACE_Time_Value::ACE_Time_Value"); - this->set (0, 0); -} - -ACE_INLINE -ACE_Time_Value::ACE_Time_Value (time_t sec, suseconds_t usec) -{ - // ACE_OS_TRACE ("ACE_Time_Value::ACE_Time_Value"); - this->set (sec, usec); -} - -/// Returns number of seconds. -ACE_INLINE time_t -ACE_Time_Value::sec (void) const -{ - // ACE_OS_TRACE ("ACE_Time_Value::sec"); - return this->tv_.tv_sec; -} - -/// Sets the number of seconds. -ACE_INLINE void -ACE_Time_Value::sec (time_t sec) -{ - // ACE_OS_TRACE ("ACE_Time_Value::sec"); - this->tv_.tv_sec = sec; -} - -/// Converts from Time_Value format into milli-seconds format. -ACE_INLINE unsigned long -ACE_Time_Value::msec (void) const -{ - // ACE_OS_TRACE ("ACE_Time_Value::msec"); - - // Note - we're truncating a value here, which can lose data. This is - // called out in the user documentation for this with a recommendation to - // use msec(ACE_UINT64&) instead, so just go ahead and truncate. - time_t secs = this->tv_.tv_sec * 1000 + this->tv_.tv_usec / 1000; - return ACE_Utils::truncate_cast (secs); -} - -ACE_INLINE ACE_UINT64 -ACE_Time_Value::get_msec () const -{ - // ACE_OS_TRACE ("ACE_Time_Value::get_msec"); - ACE_UINT64 ms = ACE_Utils::truncate_cast (this->tv_.tv_sec); - ms *= 1000; - ms += (this->tv_.tv_usec / 1000); - return ms; -} - -ACE_INLINE void -ACE_Time_Value::msec (ACE_UINT64 &ms) const -{ - // ACE_OS_TRACE ("ACE_Time_Value::msec"); - ms = this->get_msec (); -} - -ACE_INLINE void -ACE_Time_Value::msec (ACE_UINT64 &ms) /*const*/ -{ - // ACE_OS_TRACE ("ACE_Time_Value::msec"); - const ACE_Time_Value *tv = this; - tv->msec (ms); -} - -ACE_INLINE void -ACE_Time_Value::set_msec (const ACE_UINT64 &ms) -{ - // ACE_OS_TRACE ("ACE_Time_Value::set_msec"); - // Convert millisecond units to seconds; - ACE_UINT64 secs = ms / 1000; - this->tv_.tv_sec = static_cast (secs); - // Convert remainder to microseconds; - this->tv_.tv_usec = static_cast((ms - (secs * 1000)) * 1000); -} - -/// Converts from milli-seconds format into Time_Value format. -ACE_INLINE void -ACE_Time_Value::msec (long milliseconds) -{ - // ACE_OS_TRACE ("ACE_Time_Value::msec"); - // Convert millisecond units to seconds; - long secs = milliseconds / 1000; - this->tv_.tv_sec = secs; - // Convert remainder to microseconds; - this->tv_.tv_usec = (milliseconds - (secs * 1000)) * 1000; -} - -/// Converts from milli-seconds format into Time_Value format. -ACE_INLINE void -ACE_Time_Value::msec (int milliseconds) -{ - ACE_Time_Value::msec (static_cast (milliseconds)); -} - -/// Returns number of micro-seconds. -ACE_INLINE suseconds_t -ACE_Time_Value::usec (void) const -{ - // ACE_OS_TRACE ("ACE_Time_Value::usec"); - return this->tv_.tv_usec; -} - -/// Sets the number of micro-seconds. -ACE_INLINE void -ACE_Time_Value::usec (suseconds_t usec) -{ - // ACE_OS_TRACE ("ACE_Time_Value::usec"); - this->tv_.tv_usec = usec; -} - -ACE_INLINE void -ACE_Time_Value::to_usec (ACE_UINT64 & usec) const -{ - // ACE_OS_TRACE ("ACE_Time_Value::to_usec"); - usec = static_cast (this->tv_.tv_sec); - usec *= 1000000; - usec += this->tv_.tv_usec; -} - -ACE_INLINE ACE_Time_Value -operator * (double d, const ACE_Time_Value &tv) -{ - return ACE_Time_Value (tv) *= d; -} - -ACE_INLINE ACE_Time_Value -operator * (const ACE_Time_Value &tv, double d) -{ - return ACE_Time_Value (tv) *= d; -} - -/// True if tv1 > tv2. -ACE_INLINE bool -operator > (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2) -{ - // ACE_OS_TRACE ("operator >"); - if (tv1.sec () > tv2.sec ()) - return 1; - else if (tv1.sec () == tv2.sec () - && tv1.usec () > tv2.usec ()) - return 1; - else - return 0; -} - -/// True if tv1 >= tv2. -ACE_INLINE bool -operator >= (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2) -{ - // ACE_OS_TRACE ("operator >="); - if (tv1.sec () > tv2.sec ()) - return 1; - else if (tv1.sec () == tv2.sec () - && tv1.usec () >= tv2.usec ()) - return 1; - else - return 0; -} - -/// Returns the value of the object as a timespec_t. -ACE_INLINE -ACE_Time_Value::operator timespec_t () const -{ - // ACE_OS_TRACE ("ACE_Time_Value::operator timespec_t"); - timespec_t tv; - tv.tv_sec = this->sec (); - // Convert microseconds into nanoseconds. - tv.tv_nsec = this->tv_.tv_usec * 1000; - return tv; -} - -/// Initializes the ACE_Time_Value object from a timespec_t. -ACE_INLINE -ACE_Time_Value::ACE_Time_Value (const timespec_t &tv) - // : tv_ () -{ - // ACE_OS_TRACE ("ACE_Time_Value::ACE_Time_Value"); - this->set (tv); -} - -/// True if tv1 < tv2. -ACE_INLINE bool -operator < (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2) -{ - // ACE_OS_TRACE ("operator <"); - return tv2 > tv1; -} - -/// True if tv1 >= tv2. -ACE_INLINE bool -operator <= (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2) -{ - // ACE_OS_TRACE ("operator <="); - return tv2 >= tv1; -} - -/// True if tv1 == tv2. -ACE_INLINE bool -operator == (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2) -{ - // ACE_OS_TRACE ("operator =="); - return tv1.sec () == tv2.sec () - && tv1.usec () == tv2.usec (); -} - -/// True if tv1 != tv2. -ACE_INLINE bool -operator != (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2) -{ - // ACE_OS_TRACE ("operator !="); - return !(tv1 == tv2); -} - -/// Add TV to this. -ACE_INLINE ACE_Time_Value & -ACE_Time_Value::operator+= (const ACE_Time_Value &tv) -{ - // ACE_OS_TRACE ("ACE_Time_Value::operator+="); - this->sec (this->sec () + tv.sec ()); - this->usec (this->usec () + tv.usec ()); - this->normalize (); - return *this; -} - -ACE_INLINE ACE_Time_Value & -ACE_Time_Value::operator+= (time_t tv) -{ - // ACE_OS_TRACE ("ACE_Time_Value::operator+="); - this->sec (this->sec () + tv); - return *this; -} - -ACE_INLINE ACE_Time_Value & -ACE_Time_Value::operator= (time_t tv) -{ - // ACE_OS_TRACE ("ACE_Time_Value::operator="); - this->sec (tv); - this->usec (0); - return *this; -} - -/// Subtract TV to this. -ACE_INLINE ACE_Time_Value & -ACE_Time_Value::operator-= (const ACE_Time_Value &tv) -{ - // ACE_OS_TRACE ("ACE_Time_Value::operator-="); - this->sec (this->sec () - tv.sec ()); - this->usec (this->usec () - tv.usec ()); - this->normalize (); - return *this; -} - -ACE_INLINE ACE_Time_Value & -ACE_Time_Value::operator-= (time_t tv) -{ - // ACE_OS_TRACE ("ACE_Time_Value::operator-="); - this->sec (this->sec () - tv); - return *this; -} - -/// Adds two ACE_Time_Value objects together, returns the sum. -ACE_INLINE ACE_Time_Value -operator + (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2) -{ - // ACE_OS_TRACE ("operator +"); - ACE_Time_Value sum (tv1); - sum += tv2; - - return sum; -} - -/// Subtracts two ACE_Time_Value objects, returns the difference. -ACE_INLINE ACE_Time_Value -operator - (const ACE_Time_Value &tv1, - const ACE_Time_Value &tv2) -{ - // ACE_OS_TRACE ("operator -"); - ACE_Time_Value delta (tv1); - delta -= tv2; - - return delta; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#if defined (ACE_HAS_CPP11) - -// Additional chrono streaming operators. - -namespace std -{ - namespace chrono - { - ACE_INLINE nanoseconds& - operator <<(nanoseconds &ns, ACE_Time_Value const &tv) - { - ns = duration_cast(seconds{tv.sec ()}) + - duration_cast(microseconds{tv.usec()}); - return ns; - } - - ACE_INLINE microseconds& - operator <<(microseconds &us, ACE_Time_Value const &tv) - { - us= duration_cast(seconds{tv.sec ()}) + - microseconds{tv.usec()}; - return us; - } - - ACE_INLINE milliseconds& - operator <<(milliseconds &ms, ACE_Time_Value const &tv) - { - ms = duration_cast(seconds{tv.sec ()}) + - duration_cast(microseconds{tv.usec()}); - return ms; - } - - ACE_INLINE seconds& - operator <<(seconds &s, ACE_Time_Value const &tv) - { - s = seconds{tv.sec ()} + - duration_cast(microseconds{tv.usec()}); - return s; - } - - ACE_INLINE minutes& - operator <<(minutes &m, ACE_Time_Value const &tv) - { - m = duration_cast(seconds{tv.sec ()}) + - duration_cast(microseconds{tv.usec()}); - return m; - } - - ACE_INLINE hours& - operator <<(hours &h, ACE_Time_Value const &tv) - { - h = duration_cast(seconds{tv.sec ()}) + - duration_cast(microseconds{tv.usec()}); - return h; - } - - - ACE_INLINE nanoseconds& - operator +=(nanoseconds &ns, ACE_Time_Value const &tv) - { - ns += duration_cast(seconds{tv.sec ()}) + - duration_cast(microseconds{tv.usec()}); - return ns; - } - - ACE_INLINE microseconds& - operator +=(microseconds &us, ACE_Time_Value const &tv) - { - us += duration_cast(seconds{tv.sec ()}) + - microseconds{tv.usec()}; - return us; - } - - ACE_INLINE milliseconds& - operator +=(milliseconds &ms, ACE_Time_Value const &tv) - { - ms += duration_cast(seconds{tv.sec ()}) + - duration_cast(microseconds{tv.usec()}); - return ms; - } - - ACE_INLINE seconds& - operator +=(seconds &s, ACE_Time_Value const &tv) - { - s += seconds{tv.sec ()} + - duration_cast(microseconds{tv.usec()}); - return s; - } - - ACE_INLINE minutes& - operator +=(minutes &m, ACE_Time_Value const &tv) - { - m += duration_cast(seconds{tv.sec ()}) + - duration_cast(microseconds{tv.usec()}); - return m; - } - - ACE_INLINE hours& - operator +=(hours &h, ACE_Time_Value const &tv) - { - h += duration_cast(seconds{tv.sec ()}) + - duration_cast(microseconds{tv.usec()}); - return h; - } - - - ACE_INLINE nanoseconds& - operator -=(nanoseconds &ns, ACE_Time_Value const &tv) - { - ns -= duration_cast(seconds{tv.sec ()}) + - duration_cast(microseconds{tv.usec()}); - return ns; - } - - ACE_INLINE microseconds& - operator -=(microseconds &us, ACE_Time_Value const &tv) - { - us -= duration_cast(seconds{tv.sec ()}) + - microseconds{tv.usec()}; - return us; - } - - ACE_INLINE milliseconds& - operator -=(milliseconds &ms, ACE_Time_Value const &tv) - { - ms -= duration_cast(seconds{tv.sec ()}) + - duration_cast(microseconds{tv.usec()}); - return ms; - } - - ACE_INLINE seconds& - operator -=(seconds &s, ACE_Time_Value const &tv) - { - s -= seconds{tv.sec ()} + - duration_cast(microseconds{tv.usec()}); - return s; - } - - ACE_INLINE minutes& - operator -=(minutes &m, ACE_Time_Value const &tv) - { - m -= duration_cast(seconds{tv.sec ()}) + - duration_cast(microseconds{tv.usec()}); - return m; - } - - ACE_INLINE hours& - operator -=(hours &h, ACE_Time_Value const &tv) - { - h -= duration_cast(seconds{tv.sec ()}) + - duration_cast(microseconds{tv.usec()}); - return h; - } - } -} - -#endif /* ACE_HAS_CPP11 */ diff --git a/deps/acelite/ace/Time_Value_T.cpp b/deps/acelite/ace/Time_Value_T.cpp deleted file mode 100644 index 79689d904..000000000 --- a/deps/acelite/ace/Time_Value_T.cpp +++ /dev/null @@ -1,50 +0,0 @@ -#ifndef ACE_TIME_VALUE_T_CPP -#define ACE_TIME_VALUE_T_CPP - -#include "ace/Time_Value_T.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#if !defined (__ACE_INLINE__) -#include "ace/Time_Value_T.inl" -#endif /* __ACE_INLINE__ */ - -#include "ace/OS_Memory.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -template -ACE_Time_Value -ACE_Time_Value_T::now () const -{ - return this->time_policy_ (); -} - -template -ACE_Time_Value -ACE_Time_Value_T::to_relative_time () const -{ - return (*this) - this->time_policy_ (); -} - -template -ACE_Time_Value -ACE_Time_Value_T::to_absolute_time () const -{ - return (*this) + this->time_policy_ (); -} - -template -ACE_Time_Value * -ACE_Time_Value_T::duplicate () const -{ - ACE_Time_Value_T * tmp = 0; - ACE_NEW_RETURN (tmp, ACE_Time_Value_T (*this), 0); - return tmp; -} - -ACE_END_VERSIONED_NAMESPACE_DECL - -#endif /* ACE_TIME_VALUE_T_CPP */ diff --git a/deps/acelite/ace/Time_Value_T.h b/deps/acelite/ace/Time_Value_T.h deleted file mode 100644 index 3cbdf84e4..000000000 --- a/deps/acelite/ace/Time_Value_T.h +++ /dev/null @@ -1,190 +0,0 @@ -// -*- C++ -*- - -//============================================================================= -/** - * @file Time_Value_T.h - * - * @author Martin Corino - */ -//============================================================================= - -#ifndef ACE_TIME_VALUE_T_H -#define ACE_TIME_VALUE_T_H - -#include /**/ "ace/pre.h" - -#if !defined (ACE_LACKS_PRAGMA_ONCE) -# pragma once -#endif /* ACE_LACKS_PRAGMA_ONCE */ - -#include "ace/Time_Value.h" - -ACE_BEGIN_VERSIONED_NAMESPACE_DECL - -/** - * @class ACE_Time_Value - * - * @brief Operations on "timeval" structures, which express time in - * seconds (secs) and microseconds (usecs). - * - * This class centralizes all the time related processing in - * ACE. These time values are typically used in conjunction with OS - * mechanisms like