@@ -1,26 +1,27 @@

-Package: mzR

-Type: Package

-Title: parser for netCDF, mzXML, mzData and mzML files (mass

-        spectrometry data)

-Version: 1.11.2

-Author: Bernd Fischer, Steffen Neumann, Laurent Gatto, Qiang Kou

-Maintainer: Bernd Fischer <bernd.fischer@embl.de>, Steffen Neumann

-	    <sneumann@ipb-halle.de>, Laurent Gatto <lg390@cam.ac.uk>, 

-	    Qiang Kou <qkou@umail.iu.edu>

-Description: mzR provides a unified API to the common file formats and

-        parsers available for mass spectrometry data. It comes with a

-        wrapper for the ISB random access parser for mass spectrometry

-        mzXML, mzData and mzML files. The package contains the original

-        code written by the ISB, and a subset of the proteowizard

-        library for mzML. The netCDF reading code has previously been

-        used in XCMS.

-License: Artistic-2.0

-LazyLoad: yes

-Depends: Rcpp (>= 0.10.1), methods, utils

-Imports: Biobase

-Suggests: msdata (>= 0.1.9), RUnit, faahKO

-LinkingTo: Rcpp

-RcppModules: Ramp

-SystemRequirements: GNU make, NetCDF, zlib

-biocViews: Infrastructure, DataImport, Proteomics, Metabolomics,

-        MassSpectrometry

+Package: mzR

+Type: Package

+Title: parser for netCDF, mzXML, mzData and mzML files (mass

+        spectrometry data)

+Version: 1.11.3

+Author: Bernd Fischer, Steffen Neumann, Laurent Gatto, Qiang Kou

+Maintainer: Bernd Fischer <bernd.fischer@embl.de>, Steffen Neumann

+ <sneumann@ipb-halle.de>, Laurent Gatto <lg390@cam.ac.uk>,

+ Qiang Kou <qkou@umail.iu.edu>

+Description: mzR provides a unified API to the common file formats and

+        parsers available for mass spectrometry data. It comes with a

+        wrapper for the ISB random access parser for mass spectrometry

+        mzXML, mzData and mzML files. The package contains the original

+        code written by the ISB, and a subset of the proteowizard

+        library for mzML. The netCDF reading code has previously been

+        used in XCMS.

+License: Artistic-2.0

+LazyLoad: yes

+Depends: Rcpp (>= 0.10.1), methods, utils

+Imports: Biobase

+Suggests: msdata (>= 0.1.9), RUnit, faahKO

+LinkingTo: Rcpp

+RcppModules: Ramp

+SystemRequirements: GNU make, NetCDF, zlib

+biocViews: Infrastructure, DataImport, Proteomics, Metabolomics,

+        MassSpectrometry

+Packaged: 2014-06-21 21:42:58 UTC; Administrator

@@ -1,3 +1,7 @@

+CHANGES IN VERSION 1.11.3

+-------------------------

+ o Updated pwiz and fixed building on all platforms [2014-06-22 Sun]

+

 CHANGES IN VERSION 1.11.2

 -------------------------

  o adding missed src files [2014-05-28 Tue]

deleted file mode 100644

@@ -1,144 +0,0 @@

-rampInit <- function() {

-

-    result <- .C("RampRInit",

-                 PACKAGE = "mzR")

-}

-

-rampPrintFiles <- function() {

-

-    result <- .C("RampRPrintFiles",

-                 PACKAGE = "mzR")

-}

-

-rampIsFile <- function(filename) {

-

-    # The C version doesn't do anything extra

-    #.C("RampRIsFile",

-    #   as.character(filename),

-    #   isfile = logical(1),

-    #   PACKAGE = "mzR")$isfile

-

-    if (!file.exists(filename))

-        return(FALSE)

-    text <- readChar(filename, 1024)

-

-    length(text) > 0

-}

-

-rampOpen <- function(filename) {

-

-    result <- .C("RampROpen",

-                 as.character(filename),

-                 rampid = integer(1),

-                 status = integer(1),

-                 PACKAGE = "mzR")

-

-    if (result$status)

-        return(result$status)

-

-    return(result$rampid)

-}

-

-rampClose <- function(rampid) {

-

-    result <- .C("RampRClose",

-                 as.integer(rampid),

-                 PACKAGE = "mzR")

-}

-

-rampCloseAll <- function() {

-

-    result <- .C("RampRCloseAll",

-                 PACKAGE = "mzR")

-}

-

-rampNumScans <- function(rampid) {

-

-    result <- .C("RampRNumScans",

-                 as.integer(rampid),

-                 numscans = integer(1),

-                 status = integer(1),

-                 PACKAGE = "mzR")

-

-    if (result$status)

-        return(NA)

-

-    return(result$numscans)

-}

-

-rampScanHeaders <- function(rampid) {

-

-    .Call("RampRScanHeaders",

-          as.integer(rampid),

-          PACKAGE = "mzR")

-}

-

-rampSIPeaks <- function(rampid, seqNum, peaksCount) {

-

-    if (!is.integer(seqNum))

-        seqNum <- as.integer(seqNum)

-    if (!is.integer(peaksCount))

-        peaksCount <- as.integer(peaksCount)

-    .Call("RampRSIPeaks",

-          as.integer(rampid),

-          seqNum,

-          peaksCount,

-          PACKAGE = "mzR")

-}

-

-rampRawData <- function(rampid) {

-

-    scanHeaders <- rampScanHeaders(rampid)

-

-    # Some of these checks work around buggy RAMP indexing code

-    scans <- scanHeaders$msLevel == 1 & scanHeaders$seqNum > 0 &

-             !duplicated(scanHeaders$acquisitionNum) &

-             scanHeaders$peaksCount > 0

-    if ("Full" %in% levels(scanHeaders$scanType))

-        scans <- scans & scanHeaders$scanType == "Full"

-

-    scans <- which(scans)

-

-    sipeaks <- rampSIPeaks(rampid, scans, scanHeaders$peaksCount[scans])

-

-    return(list(rt = scanHeaders$retentionTime[scans],

-                acquisitionNum = scanHeaders$acquisitionNum[scans],

-                tic = scanHeaders$totIonCurrent[scans],

-                scanindex = sipeaks$scanindex,

-                mz = sipeaks$mz,

-                intensity = sipeaks$intensity,

-                polarity = scanHeaders$polarity[scans]))

-}

-

-rampRawDataMSn <- function(rampid) {

-

-    # Check if we have MSn at all

-    scanHeaders <- rampScanHeaders(rampid)

-    if (max(scanHeaders[,"msLevel"]) < 2) {

-        warning("MSn spectra requested but not found")

-        return (NULL);

-    }

-

-    # Some of these checks work around buggy RAMP indexing code

-    scans <- ( scanHeaders$msLevel >= 2 & scanHeaders$seqNum > 0

-              & !duplicated(scanHeaders$acquisitionNum)

-              & scanHeaders$peaksCount > 0)

-

-    scans <- which(scans)

-

-    sipeaks <- rampSIPeaks(rampid, scans, scanHeaders$peaksCount[scans])

-

-    retdata <- list(rt = scanHeaders$retentionTime[scans],

-                    acquisitionNum = scanHeaders$acquisitionNum[scans],

-                    precursorNum=scanHeaders$precursorScanNum[scans],

-                    precursorMZ = scanHeaders$precursorMZ[scans],

-                    precursorIntensity = scanHeaders$precursorIntensity[scans],

-                    peaksCount=scanHeaders$peaksCount[scans],

-                    msLevel = scanHeaders$msLevel[scans],

-                    precursorCharge = scanHeaders$precursorCharge[scans],

-                    scanindex = sipeaks$scanindex, collisionEnergy = scanHeaders$collisionEnergy[scans],

-                    mz = sipeaks$mz,

-                    intensity =sipeaks$intensity);

-

-    return(retdata)

-}

@@ -1,4 +1,4 @@

-BUILT_RCPP_VERSION = package_version("0.11.1")

+BUILT_RCPP_VERSION = package_version("0.11.2")

 .onLoad <-

     function(libname, pkgname) {

deleted file mode 100644

@@ -1,63 +0,0 @@

-test.oldramp.mzXML <- function() {

-    library(msdata)

-    library(mzR)

-    cdfpath <- system.file("threonine", package = "msdata")

-    filename <- list.files(cdfpath, pattern="threonine_i2_e35_pH_tree.mzXML",

-                       full.names=TRUE, recursive = TRUE)

-

-    rampid <- mzR:::rampOpen(filename)

-    if (rampid < 0)

-       stop("Could not open mzXML/mzData file")

-

-    on.exit(mzR:::rampClose(rampid))

-    rawdata <- mzR:::rampRawData(rampid)

-    mzR:::rampClose(rampid)

-}

-

-test.oldramp.mzML <- function() {

-    library(msdata)

-    library(mzR)

-    cdfpath <- system.file("microtofq", package = "msdata")

-    filename <- list.files(cdfpath, pattern="MM14.mzML",

-                       full.names=TRUE, recursive = TRUE)

-

-    rampid <- mzR:::rampOpen(filename)

-    if (rampid < 0)

-       stop("Could not open mzXML/mzData file")

-

-    on.exit(mzR:::rampClose(rampid))

-    rawdata <- mzR:::rampRawData(rampid)

-    mzR:::rampClose(rampid)

-}

-

-test.oldramp.mzData <- function() {

-    library(msdata)

-    library(mzR)

-    cdfpath <- system.file("microtofq", package = "msdata")

-    filename <- list.files(cdfpath, pattern="MM14.mzdata$",

-                       full.names=TRUE, recursive = TRUE)

-

-    rampid <- mzR:::rampOpen(filename)

-    if (rampid < 0)

-       stop("Could not open mzXML/mzData file")

-

-    on.exit(mzR:::rampClose(rampid))

-    rawdata <- mzR:::rampRawData(rampid)

-    mzR:::rampClose(rampid)

-}

-

-test.oldramp.mzData.gz <- function() {

-    library(msdata)

-    library(mzR)

-    cdfpath <- system.file("microtofq", package = "msdata")

-    filename <- list.files(cdfpath, pattern="MM14.mzdata.gz",

-                       full.names=TRUE, recursive = TRUE)

-

-    rampid <- mzR:::rampOpen(filename)

-    if (rampid < 0)

-       stop("Could not open mzXML/mzData file")

-

-    on.exit(mzR:::rampClose(rampid))

-    rawdata <- mzR:::rampRawData(rampid)

-    mzR:::rampClose(rampid)

-}

@@ -73,7 +73,7 @@ PWIZOBJECTS=\

 MZROBJECTS=cramp.o  ramp_base64.o  ramp.o  RcppRamp.o RcppRampModule.o rnetCDF.o 

-OBJECTS= $(MZROBJECTS) $(PWIZOBJECTS) rampR.o

+OBJECTS= $(MZROBJECTS) $(PWIZOBJECTS) R_init_mzR.o

 ##

 ## R complains about assert(), hence -D_NODEBUG

@@ -22,11 +22,13 @@ PWIZOBJECTS=\

 ./pwiz/utility/minimxml/SAXParser.o \

 ./boost/iostreams/src/zlib.o \

 ./boost/iostreams/src/file_descriptor.o \

-./boost/thread/src/pthread/once.o \

-./boost/thread/src/pthread/thread.o \

 ./boost/filesystem/src/operations.o \

 ./boost/filesystem/src/path.o \

+./boost/filesystem/src/path_traits.o \

 ./boost/filesystem/src/utf8_codecvt_facet.o \

+./boost/filesystem/src/windows_file_codecvt.o \

+./boost/filesystem/src/codecvt_error_category.o \

+./boost/thread/src/win32/thread.o \

 ./pwiz/data/common/MemoryIndex.o \

 ./pwiz/data/common/CVTranslator.o \

 ./pwiz/data/common/cv.o \

@@ -53,7 +55,6 @@ PWIZOBJECTS=\

 ./pwiz/data/msdata/SpectrumList_BTDX.o \

 ./pwiz/data/msdata/SpectrumInfo.o \

 ./pwiz/data/msdata/RAMPAdapter.o \

-#./pwiz/data/msdata/ramp/wglob.o \

 ./pwiz/data/msdata/LegacyAdapter.o \

 ./pwiz/data/msdata/SpectrumIterator.o \

 ./pwiz/data/msdata/MSDataFile.o \

@@ -70,21 +71,21 @@ PWIZOBJECTS=\

 ./pwiz/utility/misc/SHA1.o \

 ./pwiz/utility/misc/SHA1Calculator.o \

 ./pwiz/utility/misc/sha1calc.o \

+./pwiz/data/msdata/ramp/wglob.o \

 ./random_access_gzFile.o

-MZROBJECTS=cramp.o  ramp_base64.o  ramp.o  RcppRamp.o RcppRampModule.o rnetCDF.o

-OBJECTS= $(MZROBJECTS) $(PWIZOBJECTS) rampR.o

+MZROBJECTS=cramp.o  ramp_base64.o  ramp.o  RcppRamp.o RcppRampModule.o rnetCDF.o 

-PWIZ_LDFLAGS= -lpwiz

-PWIZ_LDFLAGS=-lpthread 

-PWIZ_CPPFLAGS=-I./boost_aux/ -I./boost -I. -DHAVE_PWIZ_MZML_LIB # -DWINDOWS_NATIVE

+OBJECTS= $(MZROBJECTS) $(PWIZOBJECTS) R_init_mzR.o

+

+PWIZ_CPPFLAGS=-I./boost_aux/ -I./boost -I. -DHAVE_PWIZ_MZML_LIB -fpermissive -DWINDOWS_NATIVE

 ## Use the R_HOME indirection to support installations of multiple R version

-PKG_CPPFLAGS=-D_LARGEFILE_SOURCE $(PWIZ_CPPFLAGS)

-PKG_CFLAGS=-D_LARGEFILE_SOURCE -I./win/$(R_ARCH) -D_MSC_VER -DWIN32_LEAN_AND_MEAN -fgnu89-inline

+PKG_CPPFLAGS=-D_LARGEFILE_SOURCE $(PWIZ_CPPFLAGS)  # last include only for cross-compiling

+PKG_CFLAGS=-D_LARGEFILE_SOURCE -I./win/$(R_ARCH) -D_MSC_VER  -fgnu89-inline

-PKG_LIBS = $(shell $(R_HOME)/bin/Rscript -e "Rcpp:::LdFlags()" ) $(PWIZ_LDFLAGS) -L./win/$(R_ARCH) -lws2_32 -lnetcdf -lz

+PKG_LIBS = $(shell $(R_HOME)/bin/Rscript -e "Rcpp:::LdFlags()" ) $(PWIZ_LDFLAGS) -L./win/$(R_ARCH) -lws2_32 -lnetcdf -lz 

 all: clean $(SHLIB)

new file mode 100644

@@ -0,0 +1,19 @@

+#include <R_ext/Rdynload.h>

+#include "rnetCDF.h"

+

+static const R_CMethodDef cMethods[] = {

+    {"NetCDFStrError", (DL_FUNC) &NetCDFStrError, 3},

+    {"NetCDFOpen", (DL_FUNC) &NetCDFOpen, 3},

+    {"NetCDFClose", (DL_FUNC) &NetCDFClose, 2},

+    {"NetCDFVarID", (DL_FUNC) &NetCDFVarID, 4},

+    {"NetCDFVarLen", (DL_FUNC) &NetCDFVarLen, 4},

+    {"NetCDFVarDouble", (DL_FUNC) &NetCDFVarDouble, 4},

+    {"NetCDFVarInt", (DL_FUNC) &NetCDFVarInt, 4},

+    {"NetCDFMSPoints", (DL_FUNC) &NetCDFMSPoints, 7},

+    {NULL, NULL, 0}

+};

+

+void R_init_mzR(DllInfo * info)

+{

+    R_registerRoutines(info, cMethods, NULL, NULL, NULL);

+}

@@ -1,8 +1,21 @@

 #ifndef _mzR_RCPP_RAMP_H

 #define _mzR_RCPP_RAMP_H

-#include "cramp.h"

 #include "Rcpp.h"

+// Taken from http://tolstoy.newcastle.edu.au/R/e2/devel/06/11/1242.html

+// and http://stackoverflow.com/questions/11588765/using-rcpp-with-windows-specific-includes

+// Undefine the Realloc macro, which is defined by both R and by Windows stuff

+// Also need to undefine the Free macro

+#if defined(__MINGW32__)

+#undef Realloc

+#undef Free

+#endif

+

+#include "cramp.h"

+

+#if defined(__MINGW32__)

+#include <windows.h>

+#endif

 class RcppRamp {

new file mode 100644

@@ -0,0 +1,63 @@

+// (C) Copyright 2012 Vicente J. Botet Escriba

+// Use, modification and distribution are subject to the

+// Boost Software License, Version 1.0. (See accompanying file

+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

+

+#include <boost/thread/detail/config.hpp>

+#ifndef BOOST_NO_EXCEPTIONS

+

+

+#include <boost/thread/future_error_code.hpp>

+

+namespace boost

+{

+

+  namespace thread_detail

+  {

+

+    class  future_error_category :

+      public boost::system::error_category

+    {

+    public:

+        virtual const char* name() const BOOST_NOEXCEPT;

+        virtual std::string message(int ev) const;

+    };

+

+    const char*

+    future_error_category::name() const BOOST_NOEXCEPT

+    {

+        return "future";

+    }

+

+    std::string

+    future_error_category::message(int ev) const

+    {

+        switch (BOOST_SCOPED_ENUM_NATIVE(future_errc)(ev))

+        {

+        case future_errc::broken_promise:

+            return std::string("The associated promise has been destructed prior "

+                          "to the associated state becoming ready.");

+        case future_errc::future_already_retrieved:

+            return std::string("The future has already been retrieved from "

+                          "the promise or packaged_task.");

+        case future_errc::promise_already_satisfied:

+            return std::string("The state of the promise has already been set.");

+        case future_errc::no_state:

+            return std::string("Operation not permitted on an object without "

+                          "an associated state.");

+        }

+        return std::string("unspecified future_errc value\n");

+    }

+    future_error_category future_error_category_var;

+  }

+

+  BOOST_THREAD_DECL

+  const system::error_category&

+  future_category() BOOST_NOEXCEPT

+  {

+      return thread_detail::future_error_category_var;

+  }

+

+}

+#endif

+

new file mode 100644

@@ -0,0 +1,38 @@

+// (C) Copyright Michael Glassford 2004.

+// (C) Copyright 2007 Anthony Williams

+// Use, modification and distribution are subject to the

+// Boost Software License, Version 1.0. (See accompanying file

+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

+

+#include <boost/thread/detail/config.hpp>

+

+#if defined(BOOST_HAS_WINTHREADS) && (defined(BOOST_THREAD_BUILD_LIB) || defined(BOOST_THREAD_TEST) || defined(UNDER_CE)) && (!defined(_MSC_VER) || defined(UNDER_CE))

+

+namespace boost

+{

+    /*

+    This file is a "null" implementation of tss cleanup; it's

+    purpose is to to eliminate link errors in cases

+    where it is known that tss cleanup is not needed.

+    */

+

+    void tss_cleanup_implemented(void)

+    {

+        /*

+        This function's sole purpose is to cause a link error in cases where

+        automatic tss cleanup is not implemented by Boost.Threads as a

+        reminder that user code is responsible for calling the necessary

+        functions at the appropriate times (and for implementing an a

+        tss_cleanup_implemented() function to eliminate the linker's

+        missing symbol error).

+

+        If Boost.Threads later implements automatic tss cleanup in cases

+        where it currently doesn't (which is the plan), the duplicate

+        symbol error will warn the user that their custom solution is no

+        longer needed and can be removed.

+        */

+    }

+

+}

+

+#endif //defined(BOOST_HAS_WINTHREADS) && defined(BOOST_THREAD_BUILD_LIB) && !defined(_MSC_VER)

new file mode 100644

@@ -0,0 +1,769 @@

+// Distributed under the Boost Software License, Version 1.0. (See

+// accompanying file LICENSE_1_0.txt or copy at

+// http://www.boost.org/LICENSE_1_0.txt)

+// (C) Copyright 2007 Anthony Williams

+// (C) Copyright 2007 David Deakins

+// (C) Copyright 2011-2013 Vicente J. Botet Escriba

+

+#ifndef _WIN32_WINNT

+#define _WIN32_WINNT 0x400

+#endif

+

+#ifndef WINVER

+#define WINVER 0x400

+#endif

+//#define BOOST_THREAD_VERSION 3

+

+#include <boost/thread/thread_only.hpp>

+#include <boost/thread/once.hpp>

+#include <boost/thread/tss.hpp>

+#include <boost/thread/condition_variable.hpp>

+#include <boost/thread/detail/tss_hooks.hpp>

+#include <boost/thread/future.hpp>

+

+#include <boost/assert.hpp>

+#include <boost/cstdint.hpp>

+#if defined BOOST_THREAD_USES_DATETIME

+#include <boost/date_time/posix_time/conversion.hpp>

+#endif

+#include <memory>

+#include <algorithm>

+#ifndef UNDER_CE

+#include <process.h>

+#endif

+#include <stdio.h>

+#include <windows.h>

+

+namespace boost

+{

+  namespace detail

+  {

+    thread_data_base::~thread_data_base()

+    {

+        for (notify_list_t::iterator i = notify.begin(), e = notify.end();

+                i != e; ++i)

+        {

+            i->second->unlock();

+            i->first->notify_all();

+        }

+        for (async_states_t::iterator i = async_states_.begin(), e = async_states_.end();

+                i != e; ++i)

+        {

+            (*i)->make_ready();

+        }

+    }

+  }

+

+    namespace

+    {

+#ifdef BOOST_THREAD_PROVIDES_ONCE_CXX11

+        boost::once_flag current_thread_tls_init_flag;

+#else

+        boost::once_flag current_thread_tls_init_flag=BOOST_ONCE_INIT;

+#endif

+#if defined(UNDER_CE)

+        // Windows CE does not define the TLS_OUT_OF_INDEXES constant.

+#define TLS_OUT_OF_INDEXES 0xFFFFFFFF

+#endif

+        DWORD current_thread_tls_key=TLS_OUT_OF_INDEXES;

+

+        void create_current_thread_tls_key()

+        {

+            //tss_cleanup_implemented(); // if anyone uses TSS, we need the cleanup linked in

+            current_thread_tls_key=TlsAlloc();

+            BOOST_ASSERT(current_thread_tls_key!=TLS_OUT_OF_INDEXES);

+        }

+

+        void cleanup_tls_key()

+        {

+            if(current_thread_tls_key!=TLS_OUT_OF_INDEXES)

+            {

+                TlsFree(current_thread_tls_key);

+                current_thread_tls_key=TLS_OUT_OF_INDEXES;

+            }

+        }

+

+        void set_current_thread_data(detail::thread_data_base* new_data)

+        {

+            boost::call_once(current_thread_tls_init_flag,create_current_thread_tls_key);

+            if (current_thread_tls_key!=TLS_OUT_OF_INDEXES)

+            {

+                BOOST_VERIFY(TlsSetValue(current_thread_tls_key,new_data));

+            }

+            else

+            {

+                BOOST_VERIFY(false);

+                //boost::throw_exception(thread_resource_error());

+            }

+        }

+

+    }

+    namespace detail

+    {

+      thread_data_base* get_current_thread_data()

+      {

+          if(current_thread_tls_key==TLS_OUT_OF_INDEXES)

+          {

+              return 0;

+          }

+          return (detail::thread_data_base*)TlsGetValue(current_thread_tls_key);

+      }

+    }

+    namespace

+    {

+#ifndef BOOST_HAS_THREADEX

+// Windows CE doesn't define _beginthreadex

+

+        struct ThreadProxyData

+        {

+            typedef unsigned (__stdcall* func)(void*);

+            func start_address_;

+            void* arglist_;

+            ThreadProxyData(func start_address,void* arglist) : start_address_(start_address), arglist_(arglist) {}

+        };

+

+        DWORD WINAPI ThreadProxy(LPVOID args)

+        {

+            std::auto_ptr<ThreadProxyData> data(reinterpret_cast<ThreadProxyData*>(args));

+            DWORD ret=data->start_address_(data->arglist_);

+            return ret;

+        }

+

+        //typedef void* uintptr_t;

+

+        inline uintptr_t _beginthreadex(void* security, unsigned stack_size, unsigned (__stdcall* start_address)(void*),

+                                              void* arglist, unsigned initflag, unsigned* thrdaddr)

+        {

+            DWORD threadID;

+            ThreadProxyData* data = new ThreadProxyData(start_address,arglist);

+            HANDLE hthread=CreateThread(static_cast<LPSECURITY_ATTRIBUTES>(security),stack_size,ThreadProxy,

+                                        data,initflag,&threadID);

+            if (hthread==0) {

+              delete data;

+              return 0;

+            }

+            *thrdaddr=threadID;

+            return reinterpret_cast<uintptr_t const>(hthread);

+        }

+

+#endif

+

+    }

+

+    namespace detail

+    {

+        struct thread_exit_callback_node

+        {

+            boost::detail::thread_exit_function_base* func;

+            thread_exit_callback_node* next;

+

+            thread_exit_callback_node(boost::detail::thread_exit_function_base* func_,

+                                      thread_exit_callback_node* next_):

+                func(func_),next(next_)

+            {}

+        };

+

+    }

+

+    namespace

+    {

+        void run_thread_exit_callbacks()

+        {

+            detail::thread_data_ptr current_thread_data(detail::get_current_thread_data(),false);

+            if(current_thread_data)

+            {

+                while(! current_thread_data->tss_data.empty() || current_thread_data->thread_exit_callbacks)

+                {

+                    while(current_thread_data->thread_exit_callbacks)

+                    {

+                        detail::thread_exit_callback_node* const current_node=current_thread_data->thread_exit_callbacks;

+                        current_thread_data->thread_exit_callbacks=current_node->next;

+                        if(current_node->func)

+                        {

+                            (*current_node->func)();

+                            boost::detail::heap_delete(current_node->func);

+                        }

+                        boost::detail::heap_delete(current_node);

+                    }

+                    for(std::map<void const*,detail::tss_data_node>::iterator next=current_thread_data->tss_data.begin(),

+                            current,

+                            end=current_thread_data->tss_data.end();

+                        next!=end;)

+                    {

+                        current=next;

+                        ++next;

+                        if(current->second.func && (current->second.value!=0))

+                        {

+                            (*current->second.func)(current->second.value);

+                        }

+                        current_thread_data->tss_data.erase(current);

+                    }

+                }

+

+                set_current_thread_data(0);

+            }

+        }

+

+        unsigned __stdcall thread_start_function(void* param)

+        {

+            detail::thread_data_base* const thread_info(reinterpret_cast<detail::thread_data_base*>(param));

+            set_current_thread_data(thread_info);

+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS

+            BOOST_TRY

+            {

+#endif

+                thread_info->run();

+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS

+            }

+            BOOST_CATCH(thread_interrupted const&)

+            {

+            }

+// Removed as it stops the debugger identifying the cause of the exception

+// Unhandled exceptions still cause the application to terminate

+//             BOOST_CATCH(...)

+//             {

+//                 std::terminate();

+//             }

+            BOOST_CATCH_END

+#endif

+            run_thread_exit_callbacks();

+            return 0;

+        }

+    }

+

+    thread::thread() BOOST_NOEXCEPT

+    {}

+

+    bool thread::start_thread_noexcept()

+    {

+        uintptr_t const new_thread=_beginthreadex(0,0,&thread_start_function,thread_info.get(),CREATE_SUSPENDED,&thread_info->id);

+        if(!new_thread)

+        {

+            return false;

+//            boost::throw_exception(thread_resource_error());

+        }

+        intrusive_ptr_add_ref(thread_info.get());

+        thread_info->thread_handle=(detail::win32::handle)(new_thread);

+        ResumeThread(thread_info->thread_handle);

+        return true;

+    }

+

+    bool thread::start_thread_noexcept(const attributes& attr)

+    {

+      //uintptr_t const new_thread=_beginthreadex(attr.get_security(),attr.get_stack_size(),&thread_start_function,thread_info.get(),CREATE_SUSPENDED,&thread_info->id);

+      uintptr_t const new_thread=_beginthreadex(0,static_cast<unsigned int>(attr.get_stack_size()),&thread_start_function,thread_info.get(),CREATE_SUSPENDED,&thread_info->id);

+      if(!new_thread)

+      {

+        return false;

+//          boost::throw_exception(thread_resource_error());

+      }

+      intrusive_ptr_add_ref(thread_info.get());

+      thread_info->thread_handle=(detail::win32::handle)(new_thread);

+      ResumeThread(thread_info->thread_handle);

+      return true;

+    }

+

+    thread::thread(detail::thread_data_ptr data):

+        thread_info(data)

+    {}

+

+    namespace

+    {

+        struct externally_launched_thread:

+            detail::thread_data_base

+        {

+            externally_launched_thread()

+            {

+                ++count;

+#if defined BOOST_THREAD_PROVIDES_INTERRUPTIONS

+                interruption_enabled=false;

+#endif

+            }

+            ~externally_launched_thread() {

+              BOOST_ASSERT(notify.empty());

+              notify.clear();

+              BOOST_ASSERT(async_states_.empty());

+              async_states_.clear();

+            }

+

+            void run()

+            {}

+            void notify_all_at_thread_exit(condition_variable*, mutex*)

+            {}

+

+        private:

+            externally_launched_thread(externally_launched_thread&);

+            void operator=(externally_launched_thread&);

+        };

+

+        void make_external_thread_data()

+        {

+            externally_launched_thread* me=detail::heap_new<externally_launched_thread>();

+            BOOST_TRY

+            {

+                set_current_thread_data(me);

+            }

+            BOOST_CATCH(...)

+            {

+                detail::heap_delete(me);

+                BOOST_RETHROW

+            }

+            BOOST_CATCH_END

+        }

+

+        detail::thread_data_base* get_or_make_current_thread_data()

+        {

+            detail::thread_data_base* current_thread_data(detail::get_current_thread_data());

+            if(!current_thread_data)

+            {

+                make_external_thread_data();

+                current_thread_data=detail::get_current_thread_data();

+            }

+            return current_thread_data;

+        }

+

+    }

+

+    thread::id thread::get_id() const BOOST_NOEXCEPT

+    {

+    #if defined BOOST_THREAD_PROVIDES_BASIC_THREAD_ID

+      detail::thread_data_ptr local_thread_info=(get_thread_info)();

+      return local_thread_info?local_thread_info->id:0;

+      //return const_cast<thread*>(this)->native_handle();

+    #else

+        return thread::id((get_thread_info)());

+    #endif

+    }

+

+    bool thread::joinable() const BOOST_NOEXCEPT

+    {

+        return (get_thread_info)() ? true : false;

+    }

+    bool thread::join_noexcept()

+    {

+

+        detail::thread_data_ptr local_thread_info=(get_thread_info)();

+        if(local_thread_info)

+        {

+            this_thread::interruptible_wait(local_thread_info->thread_handle,detail::timeout::sentinel());