ProteoWizard

Revision: 396
          http://proteowizard.svn.sourceforge.net/proteowizard/?rev=396&view=rev
Author:   chambm
Date:     2008-09-17 22:56:43 +0000 (Wed, 17 Sep 2008)

Log Message:
-----------
- changed CharIndexedVector increment and decrement to not skip over default values
- moved Modification code to a separate file for clarity; Peptide.hpp includes Modification.hpp at the end
- added Peptide::operator==
- added proteome::Digestion for simulating proteolytic digestion of peptides; digests a large peptide into smaller peptides according to digestion motif(s) or predefined enzyme(s)

Modified Paths:
--------------
    trunk/pwiz/pwiz/utility/misc/CharIndexedVector.hpp
    trunk/pwiz/pwiz/utility/proteome/Jamfile.jam
    trunk/pwiz/pwiz/utility/proteome/Peptide.cpp
    trunk/pwiz/pwiz/utility/proteome/Peptide.hpp

Added Paths:
-----------
    trunk/pwiz/pwiz/utility/proteome/Digestion.cpp
    trunk/pwiz/pwiz/utility/proteome/Digestion.hpp
    trunk/pwiz/pwiz/utility/proteome/DigestionTest.cpp
    trunk/pwiz/pwiz/utility/proteome/Modification.cpp
    trunk/pwiz/pwiz/utility/proteome/Modification.hpp

Modified: trunk/pwiz/pwiz/utility/misc/CharIndexedVector.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/misc/CharIndexedVector.hpp	2008-09-17 21:56:50 UTC (rev 395)
+++ trunk/pwiz/pwiz/utility/misc/CharIndexedVector.hpp	2008-09-17 22:56:43 UTC (rev 396)
@@ -67,39 +67,27 @@
 
     CharIndexedVectorIterator& operator++()
     {	// preincrement
-        do
-        {
-            ++m_itr;
-        } while (*m_itr == T());
+        ++m_itr;
         return (*this);
     }
 
     CharIndexedVectorIterator operator++(int)
     {	// postincrement
         CharIndexedVectorIterator _Tmp = *this;
-        do
-        {
-            ++m_itr;
-        } while (*m_itr == T());
+        ++m_itr;
         return (_Tmp);
     }
 
     CharIndexedVectorIterator& operator--()
     {	// predecrement
-        do
-        {
-            ++m_itr;
-        } while (*m_itr == T());
+        ++m_itr;
         return (*this);
     }
 
     CharIndexedVectorIterator operator--(int)
     {	// postdecrement
         CharIndexedVectorIterator _Tmp = *this;
-        do
-        {
-            ++m_itr;
-        } while (*m_itr == T());
+        ++m_itr;
         return (_Tmp);
     }
 
@@ -113,6 +101,11 @@
     {	// decrement by integer
         return (*this += -_Off);
     }
+
+    bool operator<(const CharIndexedVectorIterator& rhs)
+    {
+        return m_itr < rhs.m_itr;
+    }
 };
 
 /// a const_iterator for CharIndexedVector
@@ -152,39 +145,27 @@
 
     CharIndexedVectorConstIterator& operator++()
     {	// preincrement
-        do
-        {
-            ++m_itr;
-        } while (*m_itr == T());
+        ++m_itr;
         return (*this);
     }
 
     CharIndexedVectorConstIterator operator++(int)
     {	// postincrement
         CharIndexedVectorConstIterator _Tmp = *this;
-        do
-        {
-            ++m_itr;
-        } while (*m_itr == T());
+        ++m_itr;
         return (_Tmp);
     }
 
     CharIndexedVectorConstIterator& operator--()
     {	// predecrement
-        do
-        {
-            ++m_itr;
-        } while (*m_itr == T());
+        ++m_itr;
         return (*this);
     }
 
     CharIndexedVectorConstIterator operator--(int)
     {	// postdecrement
         CharIndexedVectorConstIterator _Tmp = *this;
-        do
-        {
-            ++m_itr;
-        } while (*m_itr == T());
+        ++m_itr;
         return (_Tmp);
     }
 
@@ -198,6 +179,11 @@
     {	// decrement by integer
         return (*this += -_Off);
     }
+
+    bool operator<(const CharIndexedVectorConstIterator& rhs)
+    {
+        return m_itr < rhs.m_itr;
+    }
 };
 
 /// a wrapper for boost::array that is indexable by character; supports indexes 0-127
@@ -217,11 +203,7 @@
 
     size_t size() const
     {
-        size_t numResidues = 0;
-        for (size_t i=0; i < 128; ++i)
-            if (type::operator[](i) != T())
-                ++ numResidues;
-        return numResidues;
+        return 128;
     }
 
     void erase(const char c)
@@ -254,10 +236,10 @@
         return type::operator[]((size_t) c);
     }
 
-    const_iterator begin() const    {return ++ const_iterator(type::begin());}
-    const_iterator end() const      {return -- const_iterator(type::end());}
-    iterator begin()                {return ++ iterator(type::begin());}
-    iterator end()                  {return -- iterator(type::end());}
+    const_iterator begin() const    {return type::begin();}
+    const_iterator end() const      {return type::end();}
+    iterator begin()                {return type::begin();}
+    iterator end()                  {return type::end();}
 };
 
 } // namespace util

Added: trunk/pwiz/pwiz/utility/proteome/Digestion.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/Digestion.cpp	                        (rev 0)
+++ trunk/pwiz/pwiz/utility/proteome/Digestion.cpp	2008-09-17 22:56:43 UTC (rev 396)
@@ -0,0 +1,560 @@
+//
+// Digestion.cpp 
+//
+//
+// Original author: Matt Chambers <matt.chambers .@. vanderbilt.edu>
+//
+// Copyright 2006 Louis Warschaw Prostate Cancer Center
+//   Cedars Sinai Medical Center, Los Angeles, California  90048
+// Copyright 2008 Vanderbilt University - Nashville, TN 37232
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License.
+//
+
+
+#define PWIZ_SOURCE
+
+#include "Digestion.hpp"
+#include "Peptide.hpp"
+#include "AminoAcid.hpp"
+#include "utility/misc/CharIndexedVector.hpp"
+#include "utility/misc/Exception.hpp"
+
+namespace pwiz {
+namespace proteome {
+
+
+using namespace std;
+using namespace pwiz::util;
+
+#undef SECURE_SCL
+
+
+PWIZ_API_DECL
+Digestion::Config::Config(int maximumMissedCleavages,
+                          //double minimumMass,
+                          //double maximumMass,
+                          int minimumLength,
+                          int maximumLength)
+:   maximumMissedCleavages(maximumMissedCleavages),
+    //minimumMass(minimumMass), maximumMass(maximumMass),
+    minimumLength(minimumLength), maximumLength(maximumLength)
+{
+}
+
+
+class Digestion::Motif::Impl
+{
+    public:
+    Impl(const string& motif)
+        :   motif_(motif)
+    {
+        parseMotif();
+    }
+
+    typedef CharIndexedVector<bool> IsValidAA;
+
+    inline bool testSite(const string& sequence, int offset) const
+    {
+        bool test = true;
+
+        // start at offset and work toward the sequence's N terminus;
+        // if testing at the N terminus (offset = -1), test '{'
+        {
+            vector<IsValidAA>::const_reverse_iterator filterItr;
+            int testOffset = offset;
+            for (filterItr = nFilters_.rbegin();
+                 test && testOffset >= 0 && filterItr != nFilters_.rend();
+                 --testOffset, ++filterItr)
+            {
+                test = (*filterItr)[sequence[testOffset]];
+            }
+            if (testOffset < 0 && test && filterItr != nFilters_.rend())
+                return (*filterItr)['{'];
+        }
+
+        if (!test)
+            return false;
+
+        // start at offset+1 and work toward the sequence's C terminus;
+        // if testing at the C terminus (offset = length-1), test '}'
+        {
+            vector<IsValidAA>::const_iterator filterItr;
+            int end = (int) sequence.length();
+            int testOffset = offset+1;
+            for (filterItr = cFilters_.begin();
+                 test && testOffset < end && filterItr != cFilters_.end();
+                 ++testOffset, ++filterItr)
+            {
+                test = (*filterItr)[sequence[testOffset]];
+            }
+            if (testOffset == end && test && filterItr != cFilters_.end())
+                return (*filterItr)['}'];
+        }
+
+        return test;
+    }
+
+    private:
+    inline void parseMotif()
+    {
+        AminoAcid::Info info;
+        vector<char> multiResidueBlock;
+		int multiResidueBlockMode = 0; // 0=off 1=contained residues are included 2=contained residues are excluded
+        bool parsedSiteDelimiter = false;
+        IsValidAA* pFilter;
+
+		for (size_t i=0, end=motif_.size(); i < end; ++i)
+		{
+			switch (motif_[i])
+			{
+				case '[':
+					// start multi residue block
+					if (multiResidueBlockMode > 0)
+						throw runtime_error("[Digestion::Motif::Impl::parseMotif()] Invalid nested multi-residue block opening bracket in motif \"" + motif_ + "\"");
+                    else if (i+1 == end)
+                        throw runtime_error("[Digestion::Motif::Impl::parseMotif()] Mismatched multi-residue block opening bracket at end of motif \"" + motif_ + "\"");
+
+					multiResidueBlockMode = ( motif_[i+1] == '^' ? 2 : 1 );
+                    if (multiResidueBlockMode == 2)
+                        ++i; // skip '^'
+					break;
+
+				case ']':
+					// close multi residue block
+					if (multiResidueBlockMode == 0)
+                        throw runtime_error("[Digestion::Motif::Impl::parseMotif()] Mismatched multi-residue block closing bracket in motif \"" + motif_ + "\"");
+                    (parsedSiteDelimiter ? cFilters_ : nFilters_).push_back(IsValidAA());
+                    pFilter = &(parsedSiteDelimiter ? cFilters_ : nFilters_).back();
+
+					if (multiResidueBlockMode == 2)
+					{
+                        // all residues are valid by default
+                        std::fill(pFilter->begin(), pFilter->end(), true);
+
+                        for (size_t j=0; j < multiResidueBlock.size(); ++j)
+                            motif_[multiResidueBlock[j]] = false;
+					}
+                    else
+					{
+                        // all residues are invalid by default
+                        std::fill(pFilter->begin(), pFilter->end(), false);
+
+						for (size_t j=0; j < multiResidueBlock.size(); ++j)
+							(*pFilter)[multiResidueBlock[j]] = true;
+					}
+				
+					multiResidueBlockMode = 0;
+					multiResidueBlock.clear();
+					break;
+
+                case '|':
+					// set last block as the modification site
+					if( multiResidueBlockMode > 0 )
+						throw runtime_error("[Digestion::Motif::Impl::parseMotif()] Digestion site specifier ('|') is invalid inside a multi-residue block in motif \"" + motif_ + "\"");
+					else
+						parsedSiteDelimiter = true;
+					break;
+
+				default:
+					if (multiResidueBlockMode > 0)
+						multiResidueBlock.push_back(motif_[i]);
+                    else
+                    {
+					    (parsedSiteDelimiter ? cFilters_ : nFilters_).push_back(IsValidAA());
+                        pFilter = &(parsedSiteDelimiter ? cFilters_ : nFilters_).back();
+
+                        if (motif_[i] == 'X' || motif_[i] == '.')
+                            std::fill(pFilter->begin(), pFilter->end(), true);
+                        else
+                            (*pFilter)[motif_[i]] = true;
+                    }
+			}
+		}
+
+		if( multiResidueBlockMode > 0 )
+            throw runtime_error("[Digestion::Motif::Impl::parseMotif()] Mismatched multi-residue block opening bracket in motif \"" + motif_ + "\"");
+    }
+
+    string motif_;
+
+    // Let offset be the residue immediately N terminal to a potential digestion site
+    // and offset+1 be the residue immediately C terminal.
+    // nFilters_.rbegin() tests offset, rbegin()+1 tests offset-1, etc.
+    // cFilters_.begin() tests offset+1, begin()+1 tests offset+1, etc.
+    vector<IsValidAA> nFilters_;
+    vector<IsValidAA> cFilters_;
+};
+
+PWIZ_API_DECL
+Digestion::Motif::Motif(const string& motif)
+:   impl_(new Impl(motif))
+{
+}
+
+PWIZ_API_DECL
+Digestion::Motif::Motif(const char* motif)
+:   impl_(new Impl(motif))
+{
+}
+
+PWIZ_API_DECL Digestion::Motif::Motif(const Motif& other)
+:   impl_(new Impl(*other.impl_))
+{
+}
+
+PWIZ_API_DECL Digestion::Motif& Digestion::Motif::operator=(const Motif& rhs)
+{
+    impl_.reset(new Impl(*rhs.impl_));
+    return *this;
+}
+
+PWIZ_API_DECL Digestion::Motif::~Motif()
+{
+}
+
+PWIZ_API_DECL bool Digestion::Motif::testSite(const string& sequence, int offset) const
+{
+    return impl_->testSite(sequence, offset);
+}
+
+
+class Digestion::Impl
+{
+    public:
+    Impl(const Peptide& peptide, const std::vector<ProteolyticEnzyme>& enzymes, const Config& config)
+        :   peptide_(peptide), config_(config)
+    {
+        motifs_.push_back(Motif("{|"));
+        motifs_.push_back(Motif("|}"));
+        for (size_t i=0; i < enzymes.size(); ++i)
+        {
+            switch (enzymes[i])
+            {
+                case ProteolyticEnzyme_Trypsin:
+                    motifs_.push_back(Motif("[KR]|"));
+                    break;
+            }
+        }
+    }
+
+    Impl(const Peptide& peptide, const vector<Motif>& motifs, const Config& config)
+        :   peptide_(peptide), motifs_(motifs), config_(config)
+    {
+        motifs_.push_back(Motif("{|"));
+        motifs_.push_back(Motif("|}"));
+    }
+
+    inline void digest() const
+    {
+        if (sites_.empty())
+        {
+            try
+            {
+                const string& sequence = peptide_.sequence();
+
+                // iterate to find all valid digestion sites
+                for (int offset = -1, end = (int) sequence.length(); offset < end; ++offset)
+                {
+                    for (size_t i=0; i < motifs_.size(); ++i)
+                    {
+                        if (motifs_[i].testSite(sequence, offset))
+                        {
+                            sites_.push_back(offset);
+                            break; // skip other motifs after finding a valid site
+                        }
+                    }
+                }
+            }
+            catch (exception& e)
+            {
+                throw runtime_error(string("[Digestion::Impl::digest()] ") + e.what());
+            }
+        }
+    }
+
+    private:
+    const Peptide& peptide_;
+    vector<Motif> motifs_;
+    Config config_;
+    friend class Digestion::const_iterator::Impl;
+
+    // precalculated offsets to digestion sites in order of occurence;
+    // the sites are between offset and offset+1;
+    // -1 is the N terminus digestion site
+    // peptide_.sequence().length()-1 is the C terminus digestion site
+    mutable vector<int> sites_;
+};
+
+PWIZ_API_DECL
+Digestion::Digestion(const Peptide& peptide,
+                     ProteolyticEnzyme enzyme,
+                     const Config& config)
+:   impl_(new Impl(peptide, vector<ProteolyticEnzyme>(1, enzyme), config))
+{
+}
+
+PWIZ_API_DECL
+Digestion::Digestion(const Peptide& peptide,
+                     const vector<ProteolyticEnzyme>& enzymes,
+                     const Config& config)
+:   impl_(new Impl(peptide, enzymes, config))
+{
+}
+
+PWIZ_API_DECL
+Digestion::Digestion(const Peptide& peptide,
+                     const Motif& motif,
+                     const Config& config)
+:   impl_(new Impl(peptide, vector<Motif>(1, motif), config))
+{
+}
+
+PWIZ_API_DECL
+Digestion::Digestion(const Peptide& peptide,
+                     const vector<Motif>& motifs,
+                     const Config& config)
+:   impl_(new Impl(peptide, motifs, config))
+{
+}
+
+PWIZ_API_DECL Digestion::~Digestion()
+{
+}
+
+PWIZ_API_DECL Digestion::const_iterator Digestion::begin() const
+{
+    return const_iterator(*this);
+}
+
+PWIZ_API_DECL Digestion::const_iterator Digestion::end() const
+{
+    return const_iterator();
+}
+
+
+class Digestion::const_iterator::Impl
+{
+    public:
+    Impl(const Digestion& digestion)
+        :   digestionImpl_(*digestion.impl_),
+            config_(digestionImpl_.config_),
+            sequence_(digestionImpl_.peptide_.sequence()),
+            sites_(digestionImpl_.sites_)
+    {
+        digestionImpl_.digest();
+        try
+        {
+            begin_ = end_ = sites_.end();
+
+            // iteration requires at least 2 digestion sites
+            if (sites_.size() < 2)
+                return;
+
+            // try each possible pair of digestion sites;
+            // initialize begin_ and end_ to the first pair that meet
+            // config's filtering criteria
+            for (size_t i=0; i < sites_.size(); ++i)
+            {
+                int testBegin = sites_[i];
+
+                for (size_t j=1; j < sites_.size(); ++j)
+                {
+                    int testEnd = sites_[j];
+                    int curLength = testEnd - testBegin;
+
+                    if (curLength > config_.maximumLength)
+                        break;
+                    if (curLength < config_.minimumLength)
+                        continue;
+
+                    begin_ = sites_.begin()+i;
+                    end_ = sites_.begin()+j;
+                    break;
+                }
+
+                if (begin_ != sites_.end())
+                    break;
+            }
+        }
+        catch (exception& e)
+        {
+            throw runtime_error(string("[Digestion::const_iterator::Impl::Impl()] ") + e.what());
+        }
+    }
+
+    const Peptide& peptide() const
+    {
+        try
+        {
+            if (!peptide_.get())
+            {
+                peptide_.reset(new Peptide(sequence_.begin()+(*begin_+1), sequence_.begin()+(*end_+1)));
+            }
+            return *peptide_;
+        }
+        catch (exception& e)
+        {
+            throw runtime_error(string("[Digestion::const_iterator::Impl::peptide()] ") + e.what());
+        }
+    }
+
+    inline Impl& operator++()
+    {
+        try
+        {
+            peptide_.release();
+
+            bool newBegin = (end_ == sites_.end());
+            if (!newBegin)
+            {
+                // advance end_ to the next digestion site
+                bool foundNextValidSitePair = false;
+                for (++end_; end_ != sites_.end(); ++end_)
+                {
+                    int curMissedCleavages = int(end_ - begin_)-1;
+                    if (curMissedCleavages > config_.maximumMissedCleavages)
+                        break;
+
+                    int curLength = *end_ - *begin_;
+                    if (curLength > config_.maximumLength)
+                        break;
+                    if (curLength < config_.minimumLength)
+                        continue;
+
+                    foundNextValidSitePair = true;
+                    break;
+                }
+
+                // there may not be another site that makes a valid site pair
+                newBegin = !foundNextValidSitePair;
+            }
+
+            if (newBegin)
+            {
+                // advance to the next valid digestion site pair
+                bool foundNextValidSitePair = false;
+                for (++begin_; begin_ != sites_.end(); ++begin_)
+                {
+                    for (end_ = begin_+1; end_ != sites_.end(); ++end_)
+                    {
+                        int curMissedCleavages = int(end_ - begin_)-1;
+                        if (curMissedCleavages > config_.maximumMissedCleavages)
+                            break;
+
+                        int curLength = *end_ - *begin_;
+                        if (curLength > config_.maximumLength)
+                            break;
+                        if (curLength < config_.minimumLength)
+                            continue;
+
+                        foundNextValidSitePair = true;
+                        break;
+                    }
+
+                    if (foundNextValidSitePair)
+                        break;
+                }
+            }
+        }
+        catch (exception& e)
+        {
+            throw runtime_error(string("[Digestion::Impl::operator++()] ") + e.what());
+        }
+
+        return *this;
+    }
+
+    inline Impl operator++(int)
+    {
+        Impl tmp(*this);
+        ++*this;
+        return tmp;
+    }
+
+    private:
+    const Digestion::Impl& digestionImpl_;
+    const Config& config_;
+    const string& sequence_;
+    const vector<int>& sites_;
+    vector<int>::const_iterator begin_; // iterator to the current peptide's N terminal offset-1
+    vector<int>::const_iterator end_; // iterator to the current peptide's C terminal offset
+    mutable auto_ptr<Peptide> peptide_;
+    friend class Digestion::const_iterator;
+};
+
+PWIZ_API_DECL Digestion::const_iterator::const_iterator()
+:   impl_(0)
+{
+}
+
+PWIZ_API_DECL Digestion::const_iterator::const_iterator(const Digestion& digestion)
+:   impl_(new Impl(digestion))
+{
+}
+
+PWIZ_API_DECL Digestion::const_iterator::const_iterator(const const_iterator& rhs)
+:   impl_(rhs.impl_.get() ? new Impl(*rhs.impl_) : 0)
+{
+}
+
+PWIZ_API_DECL Digestion::const_iterator::~const_iterator()
+{
+}
+
+PWIZ_API_DECL const Peptide& Digestion::const_iterator::operator*() const
+{
+    return impl_->peptide();
+}
+
+PWIZ_API_DECL const Peptide* Digestion::const_iterator::operator->() const
+{
+    return &(impl_->peptide());
+}
+
+PWIZ_API_DECL Digestion::const_iterator& Digestion::const_iterator::operator++()
+{
+    ++(*impl_);
+    return *this;
+}
+
+PWIZ_API_DECL Digestion::const_iterator Digestion::const_iterator::operator++(int)
+{
+    const_iterator tmp(*this);
+    ++(*impl_);
+    return tmp;
+}
+
+PWIZ_API_DECL bool Digestion::const_iterator::operator!=(const Digestion::const_iterator& that) const
+{
+    return !(*this == that);
+}
+
+PWIZ_API_DECL bool Digestion::const_iterator::operator==(const Digestion::const_iterator& that) const
+{
+    bool gotThis = this->impl_.get() != NULL;
+    bool gotThat = that.impl_.get() != NULL;
+
+    if (gotThis && gotThat)
+        return this->impl_->begin_ == that.impl_->begin_ &&
+               this->impl_->end_ == that.impl_->end_;
+    else if (!gotThis && !gotThat) // end() == end()
+        return true;
+    else if (gotThis)
+        return this->impl_->begin_ == this->impl_->sites_.end();
+    else // gotThat
+        return that.impl_->begin_ == that.impl_->sites_.end();
+}
+
+} // namespace proteome
+} // namespace pwiz

Added: trunk/pwiz/pwiz/utility/proteome/Digestion.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/Digestion.hpp	                        (rev 0)
+++ trunk/pwiz/pwiz/utility/proteome/Digestion.hpp	2008-09-17 22:56:43 UTC (rev 396)
@@ -0,0 +1,183 @@
+//
+// Digestion.hpp 
+//
+//
+// Original author: Matt Chambers <matt.chambers .@. vanderbilt.edu>
+//
+// Copyright 2006 Louis Warschaw Prostate Cancer Center
+//   Cedars Sinai Medical Center, Los Angeles, California  90048
+// Copyright 2008 Vanderbilt University - Nashville, TN 37232
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License.
+//
+
+
+#ifndef _DIGESTION_HPP_
+#define _DIGESTION_HPP_
+
+
+#include "utility/misc/Export.hpp"
+#include "Chemistry.hpp"
+#include "Peptide.hpp"
+#include <string>
+#include <memory>
+#include <limits>
+
+
+namespace pwiz {
+namespace proteome {
+
+
+/// enumeration of commonly used proteolytic enzymes or enzyme-like proteases
+enum PWIZ_API_DECL ProteolyticEnzyme
+{
+    ProteolyticEnzyme_Trypsin, /// cleaves after K/R
+    ProteolyticEnzyme_Chymotrypsin, /// cleaves after F/W/Y
+    ProteolyticEnzyme_Clostripain, /// cleaves after R
+    ProteolyticEnzyme_CyanogenBromide, /// cleaves after M when C-terminal residue is not S/T
+    ProteolyticEnzyme_Pepsin /// cleaves after F/W/Y
+};
+
+
+/// enumerates the peptides from proteolytic digestion of a polypeptide or protein;
+class PWIZ_API_DECL Digestion
+{
+    public:
+
+    /// sets constraints for valid peptides produced by iterating the digestion
+    struct PWIZ_API_DECL Config
+    {
+        int maximumMissedCleavages;
+
+        //double minimumMass;
+        //double maximumMass;
+
+        int minimumLength;
+        int maximumLength;
+
+        Config(int maximumMissedCleavages = 100000,
+               //double minimumMass = 0,
+               //double maximumMass = 100000,
+               int minimumLength = 0,
+               int maximumLength = 100000);
+    };
+
+    struct Motif;
+
+    /// specifies digestion occurs by a commonly used enzyme
+    Digestion(const Peptide& peptide,
+              ProteolyticEnzyme enzyme,
+              const Config& config = Config());
+
+    /// specifies digestion occurs by a combination of commonly used enzymes
+    Digestion(const Peptide& peptide,
+              const std::vector<ProteolyticEnzyme>& enzymes,
+              const Config& config = Config());
+
+    /// specifies digestion occurs by a user-specified motif
+    Digestion(const Peptide& peptide,
+              const Motif& motif,
+              const Config& config = Config());
+
+    /// specifies digestion occurs by a combination of user-specified motifs
+    Digestion(const Peptide& peptide,
+              const std::vector<Motif>& motifs,
+              const Config& config = Config());
+
+    ~Digestion();
+
+    /// represents a rule to test whether a peptide bond is a valid digestion site
+    struct PWIZ_API_DECL Motif
+    {
+        /// a motif is a kind of filter describing which amino acids are valid
+        /// on the N and C termini of a digestion site
+        /// Notes:
+        ///  - the semantics are slightly different than "cut / no cut"
+        ///  - the filter is specified with a limited Perl regular expression
+        ///  - the filter must have exactly one '|' indicating where the cleavage occurs
+        ///  - the supported amino acid symbol alphabet is: [ABCDEFGHIKLMNPQRSTVWXYZ]
+        ///  - use the "[<residue set>]" syntax to match any residue in the set
+        ///  - use the "[^<residue set>]" syntax to match any residue NOT in the set
+        ///  - 'X' is a wildcard indicating any amino acid or a terminus
+        ///  - '.' is synonymous with 'X' and is also allowed
+        ///  - '{' and '}' indicate the N and C termini of the polypeptide being cleaved (respectively)
+        ///  - '{' and '}' are implicitly valid as digestion sites unless explicitly disallowed
+        ///  - filters can evaluate to test more than one residue (but most will not)
+        ///  - empty filters evaluate to 'X|X'
+        ///  - if the '|' is on the edge of the filter, any amino acid or a terminus is allowed
+        ///
+        /// Examples:
+        ///  - Digest with trypsin: "[KR]|X", "[KR]|.", or "[KR]|"
+        ///  - Digest with trypsin, disallowing N terminal P: "[KR]|[^P]"
+        ///  - Digest after M at protein N terminus: "{M|X"
+        ///  - Digest with cyanogen bromide, disallowing N terminal S/T: "M|[^ST]"
+        ///  - Digest after T when it is 5 residues away from G: "GXXXXXT|X"
+        Motif(const std::string& motif);
+        Motif(const char* motif);
+        Motif(const Motif& other);
+        Motif& operator=(const Motif& rhs);
+        ~Motif();
+
+        /// returns true iff the sequence can be cleaved between offset and offset+1 using this motif;
+        /// offset < 0 tests digestion at the N terminus
+        /// offset = sequence.length()-1 tests digestion at the C terminus
+        bool testSite(const std::string& sequence, int offset) const;
+
+        private:
+        class Impl;
+        std::auto_ptr<Impl> impl_;
+    };
+
+    /// provides forward-only, read-only iteration to enumerate peptides
+    class PWIZ_API_DECL const_iterator
+    {
+        public:
+        const_iterator(const const_iterator& rhs);
+        ~const_iterator();
+
+        const Peptide& operator*() const;
+        const Peptide* operator->() const;
+        const_iterator& operator++();
+        const_iterator operator++(int);
+        bool operator!=(const const_iterator& that) const; 
+        bool operator==(const const_iterator& that) const; 
+
+        typedef std::forward_iterator_tag iterator_category;
+        typedef Peptide value_type;
+        typedef size_t difference_type;
+        typedef value_type* pointer;
+        typedef value_type& reference;
+
+        private:
+        const_iterator();
+        const_iterator(const Digestion& digestion);
+
+        friend class Digestion;
+        class Impl;
+        std::auto_ptr<Impl> impl_;
+    };
+
+    const_iterator begin() const;
+    const_iterator end() const;
+
+    private:
+    class Impl;
+    std::auto_ptr<Impl> impl_;
+};
+
+
+} // namespace proteome
+} // namespace pwiz
+
+
+#endif // _CLEAVAGE_HPP_

Added: trunk/pwiz/pwiz/utility/proteome/DigestionTest.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/DigestionTest.cpp	                        (rev 0)
+++ trunk/pwiz/pwiz/utility/proteome/DigestionTest.cpp	2008-09-17 22:56:43 UTC (rev 396)
@@ -0,0 +1,116 @@
+//
+// DigestionTest.cpp
+//
+//
+// Original author: Matt Chambers <matt.chambers .@. vanderbilt.edu>
+//
+// Copyright 2006 Louis Warschaw Prostate Cancer Center
+//   Cedars Sinai Medical Center, Los Angeles, California  90048
+// Copyright 2008 Vanderbilt University - Nashville, TN 37232
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License.
+//
+
+
+#include "Peptide.hpp"
+#include "Digestion.hpp"
+#include "utility/misc/unit.hpp"
+#include "utility/misc/String.hpp"
+#include <iostream>
+#include <iterator>
+
+using namespace std;
+using namespace pwiz::util;
+using namespace pwiz::proteome;
+
+
+ostream* os_ = 0;
+
+
+void test()
+{
+    // >P02769|ALBU_BOVIN Serum albumin - Bos taurus (Bovine).
+    Peptide bsa("MKWVTFISLLLLFSSAYSRGVFRRDTHKSEIAHRFKDLGEEHFKGLVLIAFSQYLQQCPF"
+                "DEHVKLVNELTEFAKTCVADESHAGCEKSLHTLFGDELCKVASLRETYGDMADCCEKQEP"
+                "ERNECFLSHKDDSPDLPKLKPDPNTLCDEFKADEKKFWGKYLYEIARRHPYFYAPELLYY"
+                "ANKYNGVFQECCQAEDKGACLLPKIETMREKVLASSARQRLRCASIQKFGERALKAWSVA"
+                "RLSQKFPKAEFVEVTKLVTDLTKVHKECCHGDLLECADDRADLAKYICDNQDTISSKLKE"
+                "CCDKPLLEKSHCIAEVEKDAIPENLPPLTADFAEDKDVCKNYQEAKDAFLGSFLYEYSRR"
+                "HPEYAVSVLLRLAKEYEATLEECCAKDDPHACYSTVFDKLKHLVDEPQNLIKQNCDQFEK"
+                "LGEYGFQNALIVRYTRKVPQVSTPTLVEVSRSLGKVGTRCCTKPESERMPCTEDYLSLIL"
+                "NRLCVLHEKTPVSEKVTKCCTESLVNRRPCFSALTPDETYVPKAFDEKLFTFHADICTLP"
+                "DTEKQIKKQTALVELLKHKPKATEEQLKTVMENFVAFVDKCCAADDKEACFAVEGPKLVV"
+                "STQTALA");
+
+    Digestion trypticDigestion(bsa, ProteolyticEnzyme_Trypsin, Digestion::Config(3, 5, 40));
+    vector<Peptide> trypticPeptides(trypticDigestion.begin(), trypticDigestion.end());
+
+    // test order of enumeration and trypticPeptides at the N terminus
+    unit_assert(trypticPeptides[0].sequence() == "MKWVTFISLLLLFSSAYSR");
+    unit_assert(trypticPeptides[1].sequence() == "MKWVTFISLLLLFSSAYSRGVFR");
+    unit_assert(trypticPeptides[2].sequence() == "MKWVTFISLLLLFSSAYSRGVFRR");
+
+    // test for non-tryptic trypticPeptides
+    unit_assert(!count(trypticPeptides.begin(), trypticPeptides.end(), "MKWVTFISLLLL"));
+    unit_assert(!count(trypticPeptides.begin(), trypticPeptides.end(), "STQTALA"));
+
+    // test some middle trypticPeptides
+    unit_assert(count(trypticPeptides.begin(), trypticPeptides.end(), "RDTHKSEIAHRFK"));
+    unit_assert(count(trypticPeptides.begin(), trypticPeptides.end(), "DTHKSEIAHRFK"));
+
+    // test trypticPeptides at the C terminus
+    unit_assert(count(trypticPeptides.begin(), trypticPeptides.end(), "EACFAVEGPKLVVSTQTALA"));
+    unit_assert(trypticPeptides.back().sequence() == "LVVSTQTALA");
+
+    // test maximum missed cleavages
+    unit_assert(trypticPeptides[3].sequence() != "MKWVTFISLLLLFSSAYSRGVFRRDTHK");
+    unit_assert(!count(trypticPeptides.begin(), trypticPeptides.end(), "LKPDPNTLCDEFKADEKKFWGKYLYEIARR"));
+
+    // test minimum peptide length
+    unit_assert(!count(trypticPeptides.begin(), trypticPeptides.end(), "LR"));
+    unit_assert(!count(trypticPeptides.begin(), trypticPeptides.end(), "QRLR"));
+    unit_assert(count(trypticPeptides.begin(), trypticPeptides.end(), "VLASSARQRLR"));
+
+    // test maximum peptide length
+    unit_assert(!count(trypticPeptides.begin(), trypticPeptides.end(), "MKWVTFISLLLLFSSAYSRGVFRRDTHKSEIAHRFKDLGEEHFK"));
+    unit_assert(!count(trypticPeptides.begin(), trypticPeptides.end(), bsa.sequence()));
+
+    //for (Digestion::const_iterator itr = digestion.begin(); itr != digestion.end(); ++itr)
+    //    cout << itr->sequence() << endl;
+
+
+    // test funky digestion
+    Digestion funkyDigestion(bsa, "A[DE]|[FG]", Digestion::Config(0));
+    vector<Peptide> funkyPeptides(funkyDigestion.begin(), funkyDigestion.end());
+
+    unit_assert(funkyPeptides[0].sequence() == "MKWVTFISLLLLFSSAYSRGVFRRDTHKSEIAHRFKDLGEEHFKGLVLIAFSQYLQQCPFDEHVKLVNELTEFAKTCVADESHAGCEKSLHTLFGDELCKVASLRETYGDMADCCEKQEPERNECFLSHKDDSPDLPKLKPDPNTLCDEFKADEKKFWGKYLYEIARRHPYFYAPELLYYANKYNGVFQECCQAEDKGACLLPKIETMREKVLASSARQRLRCASIQKFGERALKAWSVARLSQKFPKAE");
+    unit_assert(funkyPeptides[1].sequence() == "FVEVTKLVTDLTKVHKECCHGDLLECADDRADLAKYICDNQDTISSKLKECCDKPLLEKSHCIAEVEKDAIPENLPPLTAD");
+    unit_assert(funkyPeptides[2].sequence() == "FAEDKDVCKNYQEAKDAFLGSFLYEYSRRHPEYAVSVLLRLAKEYEATLEECCAKDDPHACYSTVFDKLKHLVDEPQNLIKQNCDQFEKLGEYGFQNALIVRYTRKVPQVSTPTLVEVSRSLGKVGTRCCTKPESERMPCTEDYLSLILNRLCVLHEKTPVSEKVTKCCTESLVNRRPCFSALTPDETYVPKAFDEKLFTFHADICTLPDTEKQIKKQTALVELLKHKPKATEEQLKTVMENFVAFVDKCCAADDKEACFAVEGPKLVVSTQTALA");
+}
+
+
+int main(int argc, char* argv[])
+{
+    try
+    {
+        if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
+        if (os_) *os_ << "DigestionTest\n";
+        test();
+        return 0;
+    }
+    catch (exception& e)
+    {
+        cerr << e.what() << endl;
+        return 1;
+    }
+}

Modified: trunk/pwiz/pwiz/utility/proteome/Jamfile.jam
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/Jamfile.jam	2008-09-17 21:56:50 UTC (rev 395)
+++ trunk/pwiz/pwiz/utility/proteome/Jamfile.jam	2008-09-17 22:56:43 UTC (rev 396)
@@ -29,7 +29,9 @@
       IsotopeCalculator.cpp 
       IsotopeEnvelopeEstimator.cpp 
       IsotopeTable.cpp 
-      Peptide.cpp 
+      Peptide.cpp
+      Modification.cpp
+      Digestion.cpp
       PeptideDatabase.cpp 
     : <toolset>msvc,<link>shared:<define>PWIZ_DYN_LINK
       <library>/ext/boost//iostreams/<boost-iostreams-zlib>on
@@ -50,6 +52,5 @@
 unit-test IsotopeTableTest : IsotopeTableTest.cpp pwiz_utility_proteome ;
 unit-test IPIFASTADatabaseTest : IPIFASTADatabaseTest.cpp pwiz_utility_proteome /ext/boost//filesystem ;
 unit-test PeptideTest : PeptideTest.cpp pwiz_utility_proteome ;
+unit-test DigestionTest : DigestionTest.cpp pwiz_utility_proteome ;
 unit-test PeptideDatabaseTest : PeptideDatabaseTest.cpp pwiz_utility_proteome /ext/boost//filesystem ;
- 
-

Added: trunk/pwiz/pwiz/utility/proteome/Modification.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/Modification.cpp	                        (rev 0)
+++ trunk/pwiz/pwiz/utility/proteome/Modification.cpp	2008-09-17 22:56:43 UTC (rev 396)
@@ -0,0 +1,355 @@
+//
+// Modification.cpp 
+//
+//
+// Original author: Matt Chambers <matt.chambers .@. vanderbilt.edu>
+//
+// Copyright 2006 Louis Warschaw Prostate Cancer Center
+//   Cedars Sinai Medical Center, Los Angeles, California  90048
+// Copyright 2008 Vanderbilt University - Nashville, TN 37232
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License.
+//
+
+
+#define PWIZ_SOURCE
+
+#include "Modification.hpp"
+#include "Peptide.hpp"
+#include <climits>
+#include "utility/misc/Exception.hpp"
+
+namespace pwiz {
+namespace proteome {
+
+
+using namespace std;
+using namespace Chemistry;
+using namespace pwiz::util;
+
+
+class Modification::Impl
+{
+    public:
+
+    Impl(const Chemistry::Formula& formula)
+        :   formula_(new Formula(formula)),
+            monoDeltaMass(formula_->monoisotopicMass()),
+            avgDeltaMass(formula_->molecularWeight())
+    {
+    }
+
+    Impl(double monoisotopicDeltaMass,
+         double averageDeltaMass)
+        :   monoDeltaMass(monoisotopicDeltaMass),
+            avgDeltaMass(averageDeltaMass)
+    {
+    }
+
+    Impl(const Impl& mod)
+        :   formula_(mod.hasFormula() ? new Formula(*mod.formula_) : NULL),
+            monoDeltaMass(mod.monoDeltaMass),
+            avgDeltaMass(mod.avgDeltaMass)
+    {
+    }
+
+    inline bool hasFormula() const
+    {
+        return formula_.get() != NULL;
+    }
+
+    inline const Chemistry::Formula& formula() const
+    {
+        if (!formula_.get())
+            throw runtime_error("[Modification::formula()] this mod was constructed with mass info only");
+        return *formula_;
+    }
+
+    inline double monoisotopicDeltaMass() const
+    {
+        return monoDeltaMass;
+    }
+
+    inline double averageDeltaMass() const
+    {
+        return avgDeltaMass;
+    }
+
+    private:
+    auto_ptr<Formula> formula_;
+    double monoDeltaMass;
+    double avgDeltaMass;
+};
+
+PWIZ_API_DECL Modification::Modification()
+:   impl_(new Impl(0, 0))
+{
+}
+
+PWIZ_API_DECL Modification::Modification(const Chemistry::Formula& formula)
+:   impl_(new Impl(formula))
+{
+}
+
+PWIZ_API_DECL Modification::Modification(double monoisotopicDeltaMass,
+                                         double averageDeltaMass)
+:   impl_(new Impl(monoisotopicDeltaMass, averageDeltaMass))
+{
+}
+
+PWIZ_API_DECL Modification::Modification(const Modification& mod)
+:   impl_(new Impl(*mod.impl_))
+{
+}
+
+PWIZ_API_DECL Modification& Modification::operator=(const Modification& rhs)
+{
+    impl_.reset(new Impl(*rhs.impl_));
+    return *this;
+}
+
+PWIZ_API_DECL Modification::~Modification() {}
+PWIZ_API_DECL bool Modification::hasFormula() const {return impl_->hasFormula();}
+PWIZ_API_DECL const Formula& Modification::formula() const {return impl_->formula();}
+PWIZ_API_DECL double Modification::monoisotopicDeltaMass() const {return impl_->monoisotopicDeltaMass();}
+PWIZ_API_DECL double Modification::averageDeltaMass() const {return impl_->averageDeltaMass();}
+
+
+PWIZ_API_DECL ModificationList::ModificationList()
+{
+}
+
+PWIZ_API_DECL ModificationList::ModificationList(const Modification& mod)
+:   vector<Modification>(1, mod)
+{
+}
+
+PWIZ_API_DECL double ModificationList::monoisotopicDeltaMass() const
+{
+    double mass = 0;
+    for (const_iterator itr = begin(); itr != end(); ++itr)
+        mass += itr->monoisotopicDeltaMass();
+    return mass;
+}
+
+PWIZ_API_DECL double ModificationList::averageDeltaMass() const
+{
+    double mass = 0;
+    for (const_iterator itr = begin(); itr != end(); ++itr)
+        mass += itr->averageDeltaMass();
+    return mass;
+}
+
+
+int ModificationMap::NTerminus() {return INT_MIN;}
+int ModificationMap::CTerminus() {return INT_MAX;}
+
+class ModificationMap::Impl
+{
+    public:
+
+    Impl(ModificationMap* mods, Peptide* peptide)
+        :   dirty_(false),
+            monoDeltaMass_(0), avgDeltaMass_(0),
+            mods_(mods), peptide_(peptide)
+    {
+    }
+
+    inline double monoDeltaMass() const
+    {
+        calculateMasses();
+        return monoDeltaMass_;
+    }
+
+    inline double avgDeltaMass() const
+    {
+        calculateMasses();
+        return avgDeltaMass_;
+    }
+
+    mutable bool dirty_;
+    mutable double monoDeltaMass_;
+    mutable double avgDeltaMass_;
+
+    private:
+
+    ModificationMap* mods_;
+    Peptide* peptide_;
+
+    inline void calculateMasses() const
+    {
+        if (dirty_)
+        {
+            dirty_ = false;
+            monoDeltaMass_ = avgDeltaMass_ = 0;
+            for (ModificationMap::const_iterator itr = mods_->begin(); itr != mods_->end(); ++itr)
+            {
+                const ModificationList& modList = itr->second;
+                monoDeltaMass_ += modList.monoisotopicDeltaMass();
+                avgDeltaMass_ += modList.averageDeltaMass();
+            }
+        }
+    }
+};
+
+PWIZ_API_DECL ModificationMap::~ModificationMap()
+{
+}
+
+PWIZ_API_DECL ModificationMap::ModificationMap(Peptide* peptide)
+:   impl_(new Impl(this, peptide))
+{
+}
+
+PWIZ_API_DECL double ModificationMap::monoisotopicDeltaMass() const
+{
+    return impl_->monoDeltaMass();
+}
+
+PWIZ_API_DECL double ModificationMap::averageDeltaMass() const
+{
+    return impl_->avgDeltaMass();
+}
+
+PWIZ_API_DECL ModificationMap::iterator ModificationMap::begin()
+{
+    impl_->dirty_ = true;
+    return virtual_map<int, ModificationList>::begin();
+}
+
+PWIZ_API_DECL ModificationMap::iterator ModificationMap::end()
+{
+    impl_->dirty_ = true;
+    return virtual_map<int, ModificationList>::end();
+}
+
+PWIZ_API_DECL ModificationMap::reverse_iterator ModificationMap::rbegin()
+{
+    impl_->dirty_ = true;
+    return virtual_map<int, ModificationList>::rbegin();
+}
+
+PWIZ_API_DECL ModificationMap::reverse_iterator ModificationMap::rend()
+{
+    impl_->dirty_ = true;
+    return virtual_map<int, ModificationList>::rend();
+}
+
+PWIZ_API_DECL
+ModificationMap::mapped_type&
+ModificationMap::operator[](const ModificationMap::key_type& x)
+{
+    impl_->dirty_ = true;
+    return virtual_map<int, ModificationList>::operator[](x);
+}
+
+PWIZ_API_DECL
+std::pair<ModificationMap::iterator, ModificationMap::iterator>
+ModificationMap::equal_range(const ModificationMap::key_type& x)
+{
+    impl_->dirty_ = true;
+    return virtual_map<int, ModificationList>::equal_range(x);
+}
+
+PWIZ_API_DECL
+ModificationMap::iterator
+ModificationMap::find(const ModificationMap::key_type& x)
+{
+    impl_->dirty_ = true;
+    return virtual_map<int, ModificationList>::find(x);
+}
+
+PWIZ_API_DECL
+ModificationMap::iterator
+ModificationMap::lower_bound(const ModificationMap::key_type& x)
+{
+    impl_->dirty_ = true;
+    return virtual_map<int, ModificationList>::lower_bound(x);
+}
+
+PWIZ_API_DECL
+ModificationMap::iterator
+ModificationMap::upper_bound(const ModificationMap::key_type& x)
+{
+    impl_->dirty_ = true;
+    return virtual_map<int, ModificationList>::upper_bound(x);
+}
+
+PWIZ_API_DECL void ModificationMap::clear()
+{
+    impl_->monoDeltaMass_ = impl_->avgDeltaMass_ = 0;
+    virtual_map<int, ModificationList>::clear();
+}
+
+PWIZ_API_DECL void ModificationMap::erase(ModificationMap::iterator position)
+{
+    const ModificationList& modList = position->second;
+    impl_->monoDeltaMass_ -= modList.monoisotopicDeltaMass();
+    impl_->avgDeltaMass_ -= modList.averageDeltaMass();
+    virtual_map<int, ModificationList>::erase(position);
+}
+
+PWIZ_API_DECL
+void ModificationMap::erase(ModificationMap::iterator start,
+                            ModificationMap::iterator finish)
+{
+    for (; start != finish; ++start)
+    {
+        const ModificationList& modList = start->second;
+        impl_->monoDeltaMass_ -= modList.monoisotopicDeltaMass();
+        impl_->avgDeltaMass_ -= modList.averageDeltaMass();
+    }
+    virtual_map<int, ModificationList>::erase(start, finish);
+}
+
+PWIZ_API_DECL ModificationMap::size_type ModificationMap::erase(const key_type& x)
+{
+    iterator itr = find(x);
+    if (itr != end())
+    {
+        erase(itr);
+        return 1;
+    }
+    return 0;
+}
+
+PWIZ_API_DECL
+std::pair<ModificationMap::iterator, bool> ModificationMap::insert(const value_type& x)
+{
+    std::pair<ModificationMap::iterator, bool> insertResult =
+        virtual_map<int, ModificationList>::insert(x);
+    if (insertResult.second)
+    {
+        const ModificationList& modList = x.second;
+        impl_->monoDeltaMass_ += modList.monoisotopicDeltaMass();
+        impl_->avgDeltaMass_ += modList.averageDeltaMass();
+    }
+    return insertResult;
+}
+
+PWIZ_API_DECL
+ModificationMap::iterator ModificationMap::insert(ModificationMap::iterator position,
+                                                  const value_type& x)
+{
+    // ignore hint because that base function won't tell us if the insert happened or not
+    return insert(x).first;
+}
+
+PWIZ_API_DECL
+void ModificationMap::swap(ModificationMap& other)
+{
+    throw runtime_error("[ModificationMap::swap()] should not be called");
+}
+
+} // namespace proteome
+} // namespace pwiz

Added: trunk/pwiz/pwiz/utility/proteome/Modification.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/Modification.hpp	                        (rev 0)
+++ trunk/pwiz/pwiz/utility/proteome/Modification.hpp	2008-09-17 22:56:43 UTC (rev 396)
@@ -0,0 +1,180 @@
+//
+// Modification.hpp 
+//
+//
+// Original author: Matt Chambers <matt.chambers .@. vanderbilt.edu>
+//
+// Copyright 2006 Louis Warschaw Prostate Cancer Center
+//   Cedars Sinai Medical Center, Los Angeles, California  90048
+// Copyright 2008 Vanderbilt University - Nashville, TN 37232
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License.
+//
+
+
+#ifndef _MODIFICATION_HPP_
+#define _MODIFICATION_HPP_
+
+
+#include "utility/misc/Export.hpp"
+#include "Chemistry.hpp"
+#include "Peptide.hpp"
+#include <string>
+#include <memory>
+#include "utility/misc/virtual_map.hpp"
+
+namespace pwiz {
+namespace proteome {
+
+/// represents a post-translational modification (PTM)
+/// modification formula or masses must be provided at instantiation
+class PWIZ_API_DECL Modification
+{
+    public:
+
+    /// constructs a zero-mass modification (provided for MSVC compatibility)
+    Modification();
+
+    Modification(const Chemistry::Formula& formula);
+    Modification(double monoisotopicDeltaMass,
+                 double averageDeltaMass);
+    Modification(const Modification&);
+    Modification& operator=(const Modification&);
+    ~Modification();
+
+    /// returns true iff the mod was constructed with formula
+    bool hasFormula() const;
+
+    /// returns the difference formula;
+    /// throws runtime_error if hasFormula() = false
+    const Chemistry::Formula& formula() const;
+
+    double monoisotopicDeltaMass() const;
+    double averageDeltaMass() const;
+
+    private:
+    class Impl;
+    std::auto_ptr<Impl> impl_;
+};
+
+
+/// represents a list of modifications on a single amino acid
+class PWIZ_API_DECL ModificationList
+    : public std::vector<Modification> // TODO: make virtual wrapper
+{
+    public:
+
+    ModificationList();
+    ModificationList(const Modification& mod);
+
+    /// returns the sum of the monoisotopic delta masses of all modifications in the list
+    double monoisotopicDeltaMass() const;
+
+    /// returns the sum of the average delta masses of all modifications in the list
+    double averageDeltaMass() const;
+};
+
+
+/// maps peptide/protein sequence indexes (0-based) to a modification list
+/// * ModificationMap::NTerminus() returns the index for specifying N terminal mods
+/// * ModificationMap::CTerminus() returns the index for specifying C terminal mods
+class PWIZ_API_DECL ModificationMap
+    : public pwiz::util::virtual_map<int, ModificationList>
+{
+    public:
+
+    ~ModificationMap();
+
+    // bring the const overloads into scope
+    using pwiz::util::virtual_map<int, ModificationList>::begin;
+    using pwiz::util::virtual_map<int, ModificationList>::end;
+    using pwiz::util::virtual_map<int, ModificationList>::rbegin;
+    using pwiz::util::virtual_map<int, ModificationList>::rend;
+    using pwiz::util::virtual_map<int, ModificationList>::operator[];
+    using pwiz::util::virtual_map<int, ModificationList>::equal_range;
+    using pwiz::util::virtual_map<int, ModificationList>::find;
+    using pwiz::util::virtual_map<int, ModificationList>::lower_bound;
+    using pwiz::util::virtual_map<int, ModificationList>::upper_bound;
+
+    static int NTerminus();
+    static int CTerminus();
+
+    /// returns the sum of the monoisotopic delta masses of all modifications in the map
+    double monoisotopicDeltaMass() const;
+
+    /// returns the sum of the average delta masses of all modifications in the map
+    double averageDeltaMass() const;
+
+    /// Returns an iterator pointing to the first element stored in the map. First is defined by the map's comparison operator, Compare.
+    virtual iterator begin();
+
+    /// Returns an iterator pointing to the last element stored in the map; in other words, to the off-the-end value.
+    virtual iterator end();
+
+    /// Returns a reverse_iterator pointing to the first element stored in the map. First is defined by the map's comparison operator, Compare.
+    virtual reverse_iterator rbegin();
+
+    /// Returns a reverse_iterator pointing to the last element stored in the map; in other words, to the off-the-end value).
+    virtual reverse_iterator rend();
+
+    /// If an element with the key x exists in the map, then a reference to its associated value is returned. Otherwise the pair x,T() is inserted into the map and a reference to the default object T() is returned.
+    virtual mapped_type& operator[](const key_type& x);
+
+    /// Returns the pair (lower_bound(x), upper_bound(x)).
+    virtual std::pair<iterator, iterator> equal_range(const key_type& x);
+
+    /// Searches the map for a pair with the key value x and returns an iterator to that pair if it is found. If such a pair is not found the value end() is returned.
+    virtual iterator find(const key_type& x);
+
+    /// Returns a reference to the first entry with a key greater than or equal to x.
+    virtual iterator lower_bound(const key_type& x);
+
+    /// Returns an iterator for the first entry with a key greater than x.
+    virtual iterator upper_bound(const key_type& x);
+
+    /// Erases all elements from the self.
+    virtual void clear();
+
+    /// Deletes the map element pointed to by the iterator position.
+    virtual void erase(iterator position);
+
+    /// If the iterators start and finish point to the same map and last is reachable from first, all elements in the range [start, finish) are deleted from the map.
+    virtual void erase(iterator start, iterator finish);
+
+    /// Deletes the element with the key value x from the map, if one exists. Returns 1 if x existed in the map, 0 otherwise.
+    virtual size_type erase(const key_type& x);
+
+    /// If a value_type with the same key as x is not present in the map, then x is inserted into the map. Otherwise, the pair is not inserted.
+    virtual std::pair<iterator, bool> insert(const value_type& x);
+
+    /// If a value_type with the same key as x is not present in the map, then x is inserted into the map. Otherwise, the pair is not inserted. A position may be supplied as a hint regarding where to do the insertion. If the insertion is done right after position, then it takes amortized constant time. Otherwise it takes O(log N) time.
+    virtual iterator insert(iterator position, const value_type& x);
+
+
+    private:
+
+    ModificationMap(Peptide* peptide);
+    class Impl;
+    std::auto_ptr<Impl> impl_;
+    ModificationMap(const ModificationMap&);
+    ModificationMap& operator=(const ModificationMap&);
+    virtual void swap(ModificationMap&);
+    friend class Peptide::Impl;
+};
+
+
+} // namespace proteome
+} // namespace pwiz
+
+
+#endif // _MODIFICATION_HPP_

Modified: trunk/pwiz/pwiz/utility/proteome/Peptide.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/Peptide.cpp	2008-09-17 21:56:50 UTC (rev 395)
+++ trunk/pwiz/pwiz/utility/proteome/Peptide.cpp	2008-09-17 22:56:43 UTC (rev 396)
@@ -24,6 +24,7 @@
 #define PWIZ_SOURCE
 
 #include "Peptide.hpp"
+#include "Modification.hpp"
 #include "AminoAcid.hpp"
 #include <iostream>
 #include <climits>
@@ -35,7 +36,6 @@
 
 using namespace std;
 using namespace Chemistry;
-using namespace pwiz::util;
 
 
 class Peptide::Impl
@@ -165,59 +165,6 @@
 };
 
 
-class Modification::Impl
-{
-    public:
-
-    Impl(const Chemistry::Formula& formula)
-        :   formula_(new Formula(formula)),
-            monoDeltaMass(formula_->monoisotopicMass()),
-            avgDeltaMass(formula_->molecularWeight())
-    {
-    }
-
-    Impl(double monoisotopicDeltaMass,
-         double averageDeltaMass)
-        :   monoDeltaMass(monoisotopicDeltaMass),
-            avgDeltaMass(averageDeltaMass)
-    {
-    }
-
-    Impl(const Impl& mod)
-        :   formula_(mod.hasFormula() ? new Formula(*mod.formula_) : NULL),
-            monoDeltaMass(mod.monoDeltaMass),
-            avgDeltaMass(mod.avgDeltaMass)
-    {
-    }
-
-    inline bool hasFormula() const
-    {
-        return formula_.get() != NULL;
-    }
-
-    inline const Chemistry::Formula& formula() const
-    {
-        if (!formula_.get())
-            throw runtime_error("[Modification::formula()] this mod was constructed with mass info only");
-        return *formula_;
-    }
-
-    inline double monoisotopicDeltaMass() const
-    {
-        return monoDeltaMass;
-    }
-
-    inline double averageDeltaMass() const
-    {
-        return avgDeltaMass;
-    }
-
-    private:
-    auto_ptr<Formula> formula_;
-    double monoDeltaMass;
-    double avgDeltaMass;
-};
-
 PWIZ_API_DECL Peptide::Peptide(const string& sequence) : impl_(new Impl(this, sequence)) {}
 PWIZ_API_DECL Peptide::Peptide(const char* sequence) : impl_(new Impl(this, sequence)) {}
 PWIZ_API_DECL Peptide::Peptide(std::string::const_iterator begin,
@@ -279,264 +226,13 @@
     return impl_->fragmentation(*this, monoisotopic, modified);
 }
 
-
-PWIZ_API_DECL Modification::Modification()
-:   impl_(new Impl(0, 0))
+PWIZ_API_DECL bool Peptide::operator==(const Peptide& rhs) const
 {
+    return impl_->sequence() == rhs.impl_->sequence() &&
+           impl_->monoMass(true) == rhs.impl_->monoMass(true);
 }
 
-PWIZ_API_DECL Modification::Modification(const Chemistry::Formula& formula)
-:   impl_(new Impl(formula))
-{
-}
 
-PWIZ_API_DECL Modification::Modification(double monoisotopicDeltaMass,
-                                         double averageDeltaMass)
-:   impl_(new Impl(monoisotopicDeltaMass, averageDeltaMass))
-{
-}
-
-PWIZ_API_DECL Modification::Modification(const Modification& mod)
-:   impl_(new Impl(*mod.impl_))
-{
-}
-
-PWIZ_API_DECL Modification& Modification::operator=(const Modification& rhs)
-{
-    impl_.reset(new Impl(*rhs.impl_));
-    return *this;
-}
-
-PWIZ_API_DECL Modification::~Modification() {}
-PWIZ_API_DECL bool Modification::hasFormula() const {return impl_->hasFormula();}
-PWIZ_API_DECL const Formula& Modification::formula() const {return impl_->formula();}
-PWIZ_API_DECL double Modification::monoisotopicDeltaMass() const {return impl_->monoisotopicDeltaMass();}
-PWIZ_API_DECL double Modification::averageDeltaMass() const {return impl_->averageDeltaMass();}
-
-
-PWIZ_API_DECL ModificationList::ModificationList()
-{
-}
-
-PWIZ_API_DECL ModificationList::ModificationList(const Modification& mod)
-:   vector<Modification>(1, mod)
-{
-}
-
-PWIZ_API_DECL double ModificationList::monoisotopicDeltaMass() const
-{
-    double mass = 0;
-    for (const_iterator itr = begin(); itr != end(); ++itr)
-        mass += itr->monoisotopicDeltaMass();
-    return mass;
-}
-
-PWIZ_API_DECL double ModificationList::averageDeltaMass() const
-{
-    double mass = 0;
-    for (const_iterator itr = begin(); itr != end(); ++itr)
-        mass += itr->averageDeltaMass();
-    return mass;
-}
-
-
-int ModificationMap::NTerminus() {return INT_MIN;}
-int ModificationMap::CTerminus() {return INT_MAX;}
-
-class ModificationMap::Impl
-{
-    public:
-
-    Impl(ModificationMap* mods, Peptide* peptide)
-        :   dirty_(false),
-            monoDeltaMass_(0), avgDeltaMass_(0),
-            mods_(mods), peptide_(peptide)
-    {
-    }
-
-    inline double monoDeltaMass() const
-    {
-        calculateMasses();
-        return monoDeltaMass_;
-    }
-
-    inline double avgDeltaMass() const
-    {
-        calculateMasses();
-        return avgDeltaMass_;
-    }
-
-    mutable bool dirty_;
-    mutable double monoDeltaMass_;
-    mutable double avgDeltaMass_;
-
-    private:
-
-    ModificationMap* mods_;
-    Peptide* peptide_;
-
-    inline void calculateMasses() const
-    {
-        if (dirty_)
-        {
-            dirty_ = false;
-            monoDeltaMass_ = avgDeltaMass_ = 0;
-            for (ModificationMap::const_iterator itr = mods_->begin(); itr != mods_->end(); ++itr)
-            {
-                const ModificationList& modList = itr->second;
-                monoDeltaMass_ += modList.monoisotopicDeltaMass();
-                avgDeltaMass_ += modList.averageDeltaMass();
-            }
-        }
-    }
-};
-
-PWIZ_API_DECL ModificationMap::ModificationMap(Peptide* peptide)
-:   impl_(new Impl(this, peptide))
-{
-}
-
-PWIZ_API_DECL double ModificationMap::monoisotopicDeltaMass() const
-{
-    return impl_->monoDeltaMass();
-}
-
-PWIZ_API_DECL double ModificationMap::averageDeltaMass() const
-{
-    return impl_->avgDeltaMass();
-}
-
-PWIZ_API_DECL ModificationMap::iterator ModificationMap::begin()
-{
-    impl_->dirty_ = true;
-    return virtual_map<int, ModificationList>::begin();
-}
-
-PWIZ_API_DECL ModificationMap::iterator ModificationMap::end()
-{
-    impl_->dirty_ = true;
-    return virtual_map<int, ModificationList>::end();
-}
-
-PWIZ_API_DECL ModificationMap::reverse_iterator ModificationMap::rbegin()
-{
-    impl_->dirty_ = true;
-    return virtual_map<int, ModificationList>::rbegin();
-}
-
-PWIZ_API_DECL ModificationMap::reverse_iterator ModificationMap::rend()
-{
-    impl_->dirty_ = true;
-    return virtual_map<int, ModificationList>::rend();
-}
-
-PWIZ_API_DECL
-ModificationMap::mapped_type&
-ModificationMap::operator[](const ModificationMap::key_type& x)
-{
-    impl_->dirty_ = true;
-    return virtual_map<int, ModificationList>::operator[](x);
-}
-
-PWIZ_API_DECL
-std::pair<ModificationMap::iterator, ModificationMap::iterator>
-ModificationMap::equal_range(const ModificationMap::key_type& x)
-{
-    impl_->dirty_ = true;
-    return virtual_map<int, ModificationList>::equal_range(x);
-}
-
-PWIZ_API_DECL
-ModificationMap::iterator
-ModificationMap::find(const ModificationMap::key_type& x)
-{
-    impl_->dirty_ = true;
-    return virtual_map<int, ModificationList>::find(x);
-}
-
-PWIZ_API_DECL
-ModificationMap::iterator
-ModificationMap::lower_bound(const ModificationMap::key_type& x)
-{
-    impl_->dirty_ = true;
-    return virtual_map<int, ModificationList>::lower_bound(x);
-}
-
-PWIZ_API_DECL
-ModificationMap::iterator
-ModificationMap::upper_bound(const ModificationMap::key_type& x)
-{
-    impl_->dirty_ = true;
-    return virtual_map<int, ModificationList>::upper_bound(x);
-}
-
-PWIZ_API_DECL void ModificationMap::clear()
-{
-    impl_->monoDeltaMass_ = impl_->avgDeltaMass_ = 0;
-    virtual_map<int, ModificationList>::clear();
-}
-
-PWIZ_API_DECL void ModificationMap::erase(ModificationMap::iterator position)
-{
-    const ModificationList& modList = position->second;
-    impl_->monoDeltaMass_ -= modList.monoisotopicDeltaMass();
-    impl_->avgDeltaMass_ -= modList.averageDeltaMass();
-    virtual_map<int, ModificationList>::erase(position);
-}
-
-PWIZ_API_DECL
-void ModificationMap::erase(ModificationMap::iterator start,
-                            ModificationMap::iterator finish)
-{
-    for (; start != finish; ++start)
-    {
-        const ModificationList& modList = start->second;
-        impl_->monoDeltaMass_ -= modList.monoisotopicDeltaMass();
-        impl_->avgDeltaMass_ -= modList.averageDeltaMass();
-    }
-    virtual_map<int, ModificationList>::erase(start, finish);
-}
-
-PWIZ_API_DECL ModificationMap::size_type ModificationMap::erase(const key_type& x)
-{
-    iterator itr = find(x);
-    if (itr != end())
-    {
-        erase(itr);
-        return 1;
-    }
-    return 0;
-}
-
-PWIZ_API_DECL
-std::pair<ModificationMap::iterator, bool> ModificationMap::insert(const value_type& x)
-{
-    std::pair<ModificationMap::iterator, bool> insertResult =
-        virtual_map<int, ModificationList>::insert(x);
-    if (insertResult.second)
-    {
-        const ModificationList& modList = x.second;
-        impl_->monoDeltaMass_ += modList.monoisotopicDeltaMass();
-        impl_->avgDeltaMass_ += modList.averageDeltaMass();
-    }
-    return insertResult;
-}
-
-PWIZ_API_DECL
-ModificationMap::iterator ModificationMap::insert(ModificationMap::iterator position,
-                                                  const value_type& x)
-{
-    // ignore hint because that base function won't tell us if the insert happened or not
-    return insert(x).first;
-}
-
-PWIZ_API_DECL
-void ModificationMap::swap(ModificationMap& other)
-{
-    throw runtime_error("[ModificationMap::swap()] should not be called");
-}
-
-
 class Fragmentation::Impl
 {
     public:

Modified: trunk/pwiz/pwiz/utility/proteome/Peptide.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/Peptide.hpp	2008-09-17 21:56:50 UTC (rev 395)
+++ trunk/pwiz/pwiz/utility/proteome/Peptide.hpp	2008-09-17 22:56:43 UTC (rev 396)
@@ -27,18 +27,14 @@
 
 #include "utility/misc/Export.hpp"
 #include "Chemistry.hpp"
-#include <string>
-#include <memory>
-#include "utility/misc/virtual_map.hpp"
 
 namespace pwiz {
 namespace proteome {
 
-class Modification;
 class ModificationMap;
 class Fragmentation;
 
-/// represents a peptide (sequence of amino acids)
+/// represents a peptide or polypeptide (a sequence of amino acids)
 class PWIZ_API_DECL Peptide
 {
     public:
@@ -82,6 +78,9 @@
     /// fragment masses can calculated as mono/avg and as modified/unmodified
     Fragmentation fragmentation(bool monoisotopic = true, bool modified = true) const;
 
+    /// returns true iff peptide sequences and masses are equal
+    bool operator==(const Peptide& rhs) const;
+
     private:
     friend class ModificationMap;
     friend class Fragmentation;
@@ -90,141 +89,10 @@
 };
 
 
-/// represents a post-translational modification (PTM)
-/// modification formula or masses must be provided at instantiation
-class PWIZ_API_DECL Modification
-{
-    public:
+/// represents a protein (a long peptide)
+typedef Peptide Protein;
 
-    /// constructs a zero-mass modification (provided for MSVC compatibility)
-    Modification();
 
-    Modification(const Chemistry::Formula& formula);
-    Modification(double monoisotopicDeltaMass,
-                 double averageDeltaMass);
-    Modification(const Modification&);
-    Modification& operator=(const Modification&);
-    ~Modification();
-
-    /// returns true iff the mod was constructed with formula
-    bool hasFormula() const;
-
-    /// returns the difference formula;
-    /// throws runtime_error if hasFormula() = false
-    const Chemistry::Formula& formula() const;
-
-    double monoisotopicDeltaMass() const;
-    double averageDeltaMass() const;
-
-    private:
-    class Impl;
-    std::auto_ptr<Impl> impl_;
-};
-
-
-/// represents a list of modifications on a single amino acid
-class PWIZ_API_DECL ModificationList
-    : public std::vector<Modification> // TODO: make virtual wrapper
-{
-    public:
-
-    ModificationList();
-    ModificationList(const Modification& mod);
-
-    /// returns the sum of the monoisotopic delta masses of all modifications in the list
-    double monoisotopicDeltaMass() const;
-
-    /// returns the sum of the average delta masses of all modifications in the list
-    double averageDeltaMass() const;
-};
-
-
-/// maps peptide/protein sequence indexes (0-based) to a modification list
-/// * ModificationMap::NTerminus() returns the index for specifying N terminal mods
-/// * ModificationMap::CTerminus() returns the index for specifying C terminal mods
-class PWIZ_API_DECL ModificationMap
-    : public pwiz::util::virtual_map<int, ModificationList>
-{
-    public:
-
-    // bring the const overloads into scope
-    using pwiz::util::virtual_map<int, ModificationList>::begin;
-    using pwiz::util::virtual_map<int, ModificationList>::end;
-    using pwiz::util::virtual_map<int, ModificationList>::rbegin;
-    using pwiz::util::virtual_map<int, ModificationList>::rend;
-    using pwiz::util::virtual_map<int, ModificationList>::operator[];
-    using pwiz::util::virtual_map<int, ModificationList>::equal_range;
-    using pwiz::util::virtual_map<int, ModificationList>::find;
-    using pwiz::util::virtual_map<int, ModificationList>::lower_bound;
-    using pwiz::util::virtual_map<int, ModificationList>::upper_bound;
-
-    static int NTerminus();
-    static int CTerminus();
-
-    /// returns the sum of the monoisotopic delta masses of all modifications in the map
-    double monoisotopicDeltaMass() const;
-
-    /// returns the sum of the average delta masses of all modifications in the map
-    double averageDeltaMass() const;
-
-    /// Returns an iterator pointing to the first element stored in the map. First is defined by the map's comparison operator, Compare.
-    virtual iterator begin();
-
-    /// Returns an iterator pointing to the last element stored in the map; in other words, to the off-the-end value.
-    virtual iterator end();
-
-    /// Returns a reverse_iterator pointing to the first element stored in the map. First is defined by the map's comparison operator, Compare.
-    virtual reverse_iterator rbegin();
-
-    /// Returns a reverse_iterator pointing to the last element stored in the map; in other words, to the off-the-end value).
-    virtual reverse_iterator rend();
-
-    /// If an element with the key x exists in the map, then a reference to its associated value is returned. Otherwise the pair x,T() is inserted into the map and a reference to the default object T() is returned.
-    virtual mapped_type& operator[](const key_type& x);
-
-    /// Returns the pair (lower_bound(x), upper_bound(x)).
-    virtual std::pair<iterator, iterator> equal_range(const key_type& x);
-
-    /// Searches the map for a pair with the key value x and returns an iterator to that pair if it is found. If such a pair is not found the value end() is returned.
-    virtual iterator find(const key_type& x);
-
-    /// Returns a reference to the first entry with a key greater than or equal to x.
-    virtual iterator lower_bound(const key_type& x);
-
-    /// Returns an iterator for the first entry with a key greater than x.
-    virtual iterator upper_bound(const key_type& x);
-
-    /// Erases all elements from the self.
-    virtual void clear();
-
-    /// Deletes the map element pointed to by the iterator position.
-    virtual void erase(iterator position);
-
-    /// If the iterators start and finish point to the same map and last is reachable from first, all elements in the range [start, finish) are deleted from the map.
-    virtual void erase(iterator start, iterator finish);
-
-    /// Deletes the element with the key value x from the map, if one exists. Returns 1 if x existed in the map, 0 otherwise.
-    virtual size_type erase(const key_type& x);
-
-    /// If a value_type with the same key as x is not present in the map, then x is inserted into the map. Otherwise, the pair is not inserted.
-    virtual std::pair<iterator, bool> insert(const value_type& x);
-
-    /// If a value_type with the same key as x is not present in the map, then x is inserted into the map. Otherwise, the pair is not inserted. A position may be supplied as a hint regarding where to do the insertion. If the insertion is done right after position, then it takes amortized constant time. Otherwise it takes O(log N) time.
-    virtual iterator insert(iterator position, const value_type& x);
-
-
-    private:
-
-    ModificationMap(Peptide* peptide);
-    class Impl;
-    std::auto_ptr<Impl> impl_;
-    ModificationMap(const ModificationMap&);
-    ModificationMap& operator=(const ModificationMap&);
-    virtual void swap(ModificationMap&);
-    friend class Peptide::Impl;
-};
-
-
 /// provides fragment ion masses for a peptide
 class PWIZ_API_DECL Fragmentation
 {
@@ -282,5 +150,9 @@
 } // namespace pwiz
 
 
+// include here for user convenience
+#include "Modification.hpp"
+
+
 #endif // _PEPTIDE_HPP_
 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 397
          http://proteowizard.svn.sourceforge.net/proteowizard/?rev=397&view=rev
Author:   dkessner
Date:     2008-09-17 23:20:44 +0000 (Wed, 17 Sep 2008)

Log Message:
-----------
moved PeptideDatabase from proteome to utility/recycle_bin

Modified Paths:
--------------
    trunk/pwiz/pwiz/utility/Jamfile.jam
    trunk/pwiz/pwiz/utility/proteome/Jamfile.jam

Added Paths:
-----------
    trunk/pwiz/pwiz/utility/recycle_bin/
    trunk/pwiz/pwiz/utility/recycle_bin/Jamfile.jam
    trunk/pwiz/pwiz/utility/recycle_bin/PeptideDatabase.cpp
    trunk/pwiz/pwiz/utility/recycle_bin/PeptideDatabase.hpp
    trunk/pwiz/pwiz/utility/recycle_bin/PeptideDatabaseTest.cpp

Removed Paths:
-------------
    trunk/pwiz/pwiz/utility/proteome/PeptideDatabase.cpp
    trunk/pwiz/pwiz/utility/proteome/PeptideDatabase.hpp
    trunk/pwiz/pwiz/utility/proteome/PeptideDatabaseTest.cpp

Modified: trunk/pwiz/pwiz/utility/Jamfile.jam
===================================================================
--- trunk/pwiz/pwiz/utility/Jamfile.jam	2008-09-17 22:56:43 UTC (rev 396)
+++ trunk/pwiz/pwiz/utility/Jamfile.jam	2008-09-17 23:20:44 UTC (rev 397)
@@ -26,4 +26,6 @@
 build-project minimxml ;
 build-project proteome ;
 build-project vendor_api ;
-build-project bindings ;
\ No newline at end of file
+build-project bindings ;
+build-project recycle_bin ;
+

Modified: trunk/pwiz/pwiz/utility/proteome/Jamfile.jam
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/Jamfile.jam	2008-09-17 22:56:43 UTC (rev 396)
+++ trunk/pwiz/pwiz/utility/proteome/Jamfile.jam	2008-09-17 23:20:44 UTC (rev 397)
@@ -32,7 +32,6 @@
       Peptide.cpp
       Modification.cpp
       Digestion.cpp
-      PeptideDatabase.cpp 
     : <toolset>msvc,<link>shared:<define>PWIZ_DYN_LINK
       <library>/ext/boost//iostreams/<boost-iostreams-zlib>on
       <library>/ext/zlib//z
@@ -53,4 +52,3 @@
 unit-test IPIFASTADatabaseTest : IPIFASTADatabaseTest.cpp pwiz_utility_proteome /ext/boost//filesystem ;
 unit-test PeptideTest : PeptideTest.cpp pwiz_utility_proteome ;
 unit-test DigestionTest : DigestionTest.cpp pwiz_utility_proteome ;
-unit-test PeptideDatabaseTest : PeptideDatabaseTest.cpp pwiz_utility_proteome /ext/boost//filesystem ;

Deleted: trunk/pwiz/pwiz/utility/proteome/PeptideDatabase.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/PeptideDatabase.cpp	2008-09-17 22:56:43 UTC (rev 396)
+++ trunk/pwiz/pwiz/utility/proteome/PeptideDatabase.cpp	2008-09-17 23:20:44 UTC (rev 397)
@@ -1,318 +0,0 @@
-//
-// PeptideDatabase.cpp 
-//
-//
-// Original author: Darren Kessner <Darren.Kessner@...>
-//
-// Copyright 2006 Louis Warschaw Prostate Cancer Center
-//   Cedars Sinai Medical Center, Los Angeles, California  90048
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License.
-//
-
-
-#define PWIZ_SOURCE
-
-#include "PeptideDatabase.hpp"
-#include "boost/iostreams/device/mapped_file.hpp"
-#include <iostream>
-#include <vector>
-#include <stdexcept>
-#include <fstream>
-
-
-namespace pwiz {
-namespace proteome {
-
-
-using namespace std;
-
-
-//
-//  The PeptideDatabase interface has two implementations:
-//
-//  1) PeptideDatabaseImpl_Memory is instantiated by PeptideDatabase::create(void).
-//     It is a writeable database that uses dynamic arrays internally.
-//     It can be written out to a binary file, which can be read by PeptideDatabaseImpl_File.
-//
-//  2) PeptideDatabaseImpl_File is instantiated by PeptideDatabase::create(filename).
-//     It is a read-only database that is backed by a binary file. 
-//     It uses the boost memory-mapped file objects, which abstract the different
-//     memory-mapped file facilities in Windows and POSIX. 
-//
-//  The binary file format was designed to have constant-size records, to allow for 
-//  efficient binary searches.  To accomodate variable-length amino acid sequences, 
-//  each PeptideDatabaseRecord has a sequenceKey, which is an offset into a string table.
-//  The string table follows the main records in the file.
-//
-//  pseudo_struct binary_file_format
-//  {
-//      PDBHeader header;
-//      PeptideDatabaseRecord records[header.recordCount];
-//      char stringTable[header.stringTableSize];
-//  };
-//
-
-
-PWIZ_API_DECL ostream& operator<<(ostream& os, const PeptideDatabaseFormula& formula)
-{
-    os << "C" << formula.C 
-        << " H" << formula.H
-        << " N" << formula.N
-        << " O" << formula.O
-        << " S" << formula.S;
-	
-	return os;
-}
-
-
-PWIZ_API_DECL bool operator==(const PeptideDatabaseFormula& r, const PeptideDatabaseFormula& s) 
-{
-    return (r.C == s.C &&
-            r.H == s.H &&
-            r.N == s.N &&
-            r.O == s.O &&
-            r.S == s.S);
-}
-
-
-PWIZ_API_DECL ostream& operator<<(ostream& os, const PeptideDatabaseRecord& record)
-{
-    os << record.abundance << " " << record.mass << " " << record.formula; 
-	return os;
-}
-
-
-#pragma pack(1)
-struct PDBHeader
-{
-    char magic[4]; // "PCC\0"
-    char type[4];  // "PDB\0" (Peptide DataBase)
-    int version;
-    int recordsOffset;
-    int recordCount;
-    int stringTableOffset;
-    int stringTableSize;
-
-    PDBHeader()
-    :   version(1), // increment here if format changes
-        recordsOffset(0),
-        recordCount(0),
-        stringTableOffset(0),
-        stringTableSize(0)
-    {
-        strncpy(magic, "PCC\0", 4);
-        strncpy(type, "PDB\0", 4);
-    }
-};
-#pragma pack()
-
-
-class PeptideDatabaseImpl_Memory : public PeptideDatabase 
-{
-    public:
-    PeptideDatabaseImpl_Memory();
-    virtual int size() const;
-    virtual const PeptideDatabaseRecord* records() const;
-    virtual string sequence(const PeptideDatabaseRecord& record) const;
-    virtual void append(const PeptideDatabaseRecord& record, const string& sequence);
-    virtual void write(const string& filename) const;
-
-    private:
-    vector<PeptideDatabaseRecord> records_;
-    string stringTable_;
-};
-
-
-PeptideDatabaseImpl_Memory::PeptideDatabaseImpl_Memory()
-{
-    stringTable_ += '\0'; // sequenceKey==0 -> null string
-}
-
-
-int PeptideDatabaseImpl_Memory::size() const 
-{
-    return (int)records_.size();
-}
-
-
-const PeptideDatabaseRecord* PeptideDatabaseImpl_Memory::records() const 
-{
-    if (records_.empty())
-        throw logic_error("[PeptideDatabaseImpl_Memory::records()]  No records.");
-    return &records_[0];
-} 
-
-
-string PeptideDatabaseImpl_Memory::sequence(const PeptideDatabaseRecord& record) const
-{
-    return string(stringTable_.data() + record.sequenceKey); 
-}
-
-
-void PeptideDatabaseImpl_Memory::append(const PeptideDatabaseRecord& record, const string& sequence)
-{
-    if (record.sequenceKey != 0) 
-        throw logic_error("[PeptideDatabaseImpl_Memory::append()] Non-zero sequenceKey."); 
-
-    records_.push_back(record);
-    
-    if (!sequence.empty())
-    {
-        PeptideDatabaseRecord& r = records_[records_.size()-1];
-        r.sequenceKey = (int)stringTable_.size(); 
-        stringTable_ += sequence + '\0';
-    }
-}
-
-
-void PeptideDatabaseImpl_Memory::write(const string& filename) const
-{
-    if (records_.empty())
-        throw logic_error("[PeptideDatabaseImpl_Memory::write()]  No records.");
-    
-    ofstream os(filename.c_str(), ios::binary);
-    if (!os)
-        throw runtime_error("[PeptideDatabaseImpl_Memory::write()] Unable to open file " + filename);
-    
-    PDBHeader header;
-    header.recordsOffset = sizeof(header);
-    header.recordCount = (int)records_.size();
-    header.stringTableOffset = header.recordsOffset + header.recordCount*sizeof(PeptideDatabaseRecord);
-    header.stringTableSize = (int)stringTable_.size();
-
-    os.write((const char*)&header, sizeof(header));
-    os.write((const char*)&records_[0], header.recordCount*sizeof(PeptideDatabaseRecord)); 
-    os.write(stringTable_.c_str(), (streamsize)stringTable_.size());
-}
-
-
-class PeptideDatabaseImpl_File : public PeptideDatabase 
-{
-    public:
-    PeptideDatabaseImpl_File(const string& filename);
-    virtual int size() const;
-    virtual const PeptideDatabaseRecord* records() const;
-    virtual string sequence(const PeptideDatabaseRecord& record) const;
-    virtual void append(const PeptideDatabaseRecord& record, const string& sequence);
-    virtual void write(const string& filename) const;
-
-    private:
-    boost::iostreams::mapped_file_source file_;
-    const PDBHeader* header_;
-    int recordCount_;
-    const PeptideDatabaseRecord* records_;
-    int stringTableSize_;
-    const char* stringTable_;
-};
-
-
-PeptideDatabaseImpl_File::PeptideDatabaseImpl_File(const string& filename)
-:   file_(filename), 
-    header_(0),
-    recordCount_(0), records_(0),
-    stringTableSize_(0), stringTable_(0)
-{
-    header_ = reinterpret_cast<const PDBHeader*>(file_.data());
-
-    PDBHeader good;
-    if (strncmp(header_->magic, good.magic, 4) ||
-        strncmp(header_->type, good.type, 4) ||
-        header_->version != good.version)
-        throw runtime_error("[PeptideDatabaseImpl_File::PeptideDatabaseImpl_File] '" + filename + "' has an invalid header.");
-
-    recordCount_ = header_->recordCount;
-    records_ = reinterpret_cast<const PeptideDatabaseRecord*>(file_.data() + header_->recordsOffset); 
-    stringTableSize_ = header_->stringTableSize;
-    stringTable_ = reinterpret_cast<const char*>(file_.data() + header_->stringTableOffset);
-}
-
-
-int PeptideDatabaseImpl_File::size() const
-{
-    return recordCount_; 
-}
-
-
-const PeptideDatabaseRecord* PeptideDatabaseImpl_File::records() const
-{
-    return records_; 
-}
-
-
-string PeptideDatabaseImpl_File::sequence(const PeptideDatabaseRecord& record) const
-{
-    return string(stringTable_ + record.sequenceKey);
-}
-
-
-void PeptideDatabaseImpl_File::append(const PeptideDatabaseRecord& record, const string& sequence)
-{
-    // this will never be called, since clients cannot obtain a non-const this
-    throw logic_error("PeptideDatabaseImpl_File::append() not implemented.");
-}
-
-
-void PeptideDatabaseImpl_File::write(const string& filename) const
-{
-    // this should never be needed
-    throw logic_error("PeptideDatabaseImpl_File::write() not implemented.");
-}
-
-
-PWIZ_API_DECL auto_ptr<PeptideDatabase> PeptideDatabase::create()
-{
-    return auto_ptr<PeptideDatabase>(new PeptideDatabaseImpl_Memory);
-}
-
-
-PWIZ_API_DECL auto_ptr<const PeptideDatabase> PeptideDatabase::create(const string& filename)
-{
-    try 
-    {
-        return auto_ptr<const PeptideDatabase>(new PeptideDatabaseImpl_File(filename));
-    }
-    catch (BOOST_IOSTREAMS_FAILURE&)
-    {
-        throw runtime_error("[PeptideDatabase::create()] Unable to map file " + filename); 
-    }
-}
-
-
-namespace {
-bool hasSmallerMass(const PeptideDatabaseRecord& a, const PeptideDatabaseRecord& b)
-{
-    return a.mass < b.mass;
-}
-} // namespace
-
-
-PWIZ_API_DECL PeptideDatabase::iterator PeptideDatabase::mass_lower_bound(double mass) const
-{
-    PeptideDatabaseRecord record;
-    record.mass = mass;
-    return lower_bound(begin(), end(), record, hasSmallerMass);
-}
-
-
-PWIZ_API_DECL PeptideDatabase::iterator PeptideDatabase::mass_upper_bound(double mass) const
-{
-    PeptideDatabaseRecord record;
-    record.mass = mass;
-    return upper_bound(begin(), end(), record, hasSmallerMass);
-}
-
-
-} // namespace proteome
-} // namespace pwiz
-

Deleted: trunk/pwiz/pwiz/utility/proteome/PeptideDatabase.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/PeptideDatabase.hpp	2008-09-17 22:56:43 UTC (rev 396)
+++ trunk/pwiz/pwiz/utility/proteome/PeptideDatabase.hpp	2008-09-17 23:20:44 UTC (rev 397)
@@ -1,110 +0,0 @@
-//
-// PeptideDatabase.hpp 
-//
-//
-// Original author: Darren Kessner <Darren.Kessner@...>
-//
-// Copyright 2006 Louis Warschaw Prostate Cancer Center
-//   Cedars Sinai Medical Center, Los Angeles, California  90048
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License.
-//
-
-
-#ifndef _PEPTIDEDATABASE_HPP_
-#define _PEPTIDEDATABASE_HPP_ 
-
-
-#include "utility/misc/Export.hpp"
-#include <string>
-#include <memory>
-
-
-namespace pwiz {
-namespace proteome {
-
-
-#pragma pack(1)
-struct PWIZ_API_DECL PeptideDatabaseFormula
-{
-    int C;
-    int H;
-    int N;
-    int O;
-    int S;
-
-    PeptideDatabaseFormula(int c=0, int h=0, int n=0, int o=0, int s=0)
-    :   C(c), H(h), N(n), O(o), S(s)
-    {}
-};
-#pragma pack()
-
-
-PWIZ_API_DECL std::ostream& operator<<(std::ostream& os, const PeptideDatabaseFormula& formula);
-
-
-#pragma pack(1)
-struct PWIZ_API_DECL PeptideDatabaseRecord
-{
-    int id_ipi;
-    double abundance;
-    double mass;
-    PeptideDatabaseFormula formula;
-    int sequenceKey;
-
-    PeptideDatabaseRecord()
-    :   id_ipi(0), abundance(1), mass(0), sequenceKey(0)
-    {}
-};
-#pragma pack()
-
-
-PWIZ_API_DECL std::ostream& operator<<(std::ostream& os, const PeptideDatabaseRecord& record);
-PWIZ_API_DECL bool operator==(const PeptideDatabaseFormula& r, const PeptideDatabaseFormula& s); 
-
-
-class PWIZ_API_DECL PeptideDatabase
-{
-    public:
-
-    static std::auto_ptr<PeptideDatabase> create();
-    static std::auto_ptr<const PeptideDatabase> create(const std::string& filename);
-    virtual ~PeptideDatabase(){}
-
-    virtual int size() const = 0;
-    virtual const PeptideDatabaseRecord* records() const = 0;
-    virtual std::string sequence(const PeptideDatabaseRecord& record) const = 0;
-
-    virtual void append(const PeptideDatabaseRecord& record, const std::string& sequence = "") = 0;
-    //virtual void append(const std::string& sequence) = 0;
-    virtual void write(const std::string& filename) const = 0;
-
-    // sortByMass() (rewriteStringTable)
-
-    // iterator interface
-    typedef const PeptideDatabaseRecord* iterator;
-    iterator begin() const {return records();}
-    iterator end() const {return records() + size();}
-
-    // range access (binary search algorithms assume database is sorted by mass)
-    iterator mass_lower_bound(double mass) const;
-    iterator mass_upper_bound(double mass) const;
-};
-
-
-} // namespace pwiz
-} // namespace proteome
-
-
-#endif // _PEPTIDEDATABASE_HPP_ 
-

Deleted: trunk/pwiz/pwiz/utility/proteome/PeptideDatabaseTest.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/PeptideDatabaseTest.cpp	2008-09-17 22:56:43 UTC (rev 396)
+++ trunk/pwiz/pwiz/utility/proteome/PeptideDatabaseTest.cpp	2008-09-17 23:20:44 UTC (rev 397)
@@ -1,141 +0,0 @@
-//
-// PeptideDatabaseTest.cpp
-//
-//
-// Original author: Darren Kessner <Darren.Kessner@...>
-//
-// Copyright 2006 Louis Warschaw Prostate Cancer Center
-//   Cedars Sinai Medical Center, Los Angeles, California  90048
-//
-// Licensed under the Apache License, Version 2.0 (the "License"); 
-// you may not use this file except in compliance with the License. 
-// You may obtain a copy of the License at 
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software 
-// distributed under the License is distributed on an "AS IS" BASIS, 
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-// See the License for the specific language governing permissions and 
-// limitations under the License.
-//
-
-
-#include "PeptideDatabase.hpp"
-#include "utility/misc/unit.hpp"
-#include <boost/filesystem/operations.hpp>
-#include <iostream>
-
-
-using namespace std;
-using namespace pwiz::util;
-using namespace pwiz::proteome;
-
-
-ostream* os_ = 0;
-
-
-void compareRecords(const PeptideDatabase* pdb1, const PeptideDatabaseRecord* record1,
-                    const PeptideDatabase* pdb2, const PeptideDatabaseRecord* record2)
-{
-    unit_assert(record1->id_ipi == record2->id_ipi);
-    unit_assert(record1->abundance == record2->abundance);
-    unit_assert(record1->mass == record2->mass);
-    unit_assert(record1->formula == record2->formula);
-    unit_assert(pdb1->sequence(*record1) == pdb2->sequence(*record2));
-}
-
-
-void test_basic()
-{
-    auto_ptr<PeptideDatabase> pdb = PeptideDatabase::create();
-
-    PeptideDatabaseRecord record;
-
-    record.abundance = 10;
-    record.mass = 27;
-    record.formula = PeptideDatabaseFormula(1, 2, 3, 4, 5);
-    pdb->append(record, "darren");
-
-    record.abundance = 20;
-    record.mass = 666;
-    record.formula = PeptideDatabaseFormula(6, 7, 8, 9, 10);
-    pdb->append(record, "goo");
-
-    unit_assert(pdb->size()==2);
-   
-    const PeptideDatabaseRecord* p = pdb->records();
-    unit_assert(p->abundance == 10);
-    unit_assert(p->mass == 27);
-    unit_assert(p->formula.C == 1); 
-    unit_assert(pdb->sequence(*p) == "darren");
-    
-    p++;
-    unit_assert(p->abundance == 20);
-    unit_assert(p->mass == 666);
-    unit_assert(p->formula.C == 6);
-    unit_assert(p->formula.S == 10);
-    unit_assert(pdb->sequence(*p) == "goo");
-     
-    // iterator interface 
-    if (os_)
-        for (PeptideDatabase::iterator it=pdb->begin(); it!=pdb->end(); ++it) 
-            *os_ << *it << " " << pdb->sequence(*it) << endl;
-
-    // test i/o
-    string filename = "PeptideDatabaseTest.output.pdb";
-    {
-        pdb->write(filename);
-        auto_ptr<const PeptideDatabase> pdb2 = PeptideDatabase::create(filename);
-        unit_assert(pdb2->size() == pdb->size());
-      
-        for (int i=0; i<pdb->size(); ++i)
-        {
-            const PeptideDatabaseRecord* record1 = pdb->records()+i;
-            const PeptideDatabaseRecord* record2 = pdb2->records()+i;
-            compareRecords(pdb.get(), record1, pdb2.get(), record2);
-        }
-    }
-
-    boost::filesystem::remove(filename);
-}
-        
-        
-void test_range()
-{
-    auto_ptr<PeptideDatabase> pdb = PeptideDatabase::create();
-
-    for (int i=0; i<10; i++)
-    {
-        PeptideDatabaseRecord record;
-        record.mass = i;
-        pdb->append(record);
-    }
-
-    PeptideDatabase::iterator begin = pdb->begin();
-    PeptideDatabase::iterator six = pdb->mass_lower_bound(5.5);
-    PeptideDatabase::iterator eight = pdb->mass_upper_bound(7.5);
-    unit_assert(six == begin+6);
-    unit_assert(eight == begin+8);
-}
-
-
-int main(int argc, char* argv[])
-{
-
-    try
-    {
-        if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
-        if (os_) *os_ << "PeptideDatabaseTest\n";
-        test_basic();
-        test_range();
-        return 0;
-    }
-    catch (exception& e)
-    {
-        cerr << e.what() << endl;
-        return 1;
-    }
-}
-
-

Added: trunk/pwiz/pwiz/utility/recycle_bin/Jamfile.jam
===================================================================
--- trunk/pwiz/pwiz/utility/recycle_bin/Jamfile.jam	                        (rev 0)
+++ trunk/pwiz/pwiz/utility/recycle_bin/Jamfile.jam	2008-09-17 23:20:44 UTC (rev 397)
@@ -0,0 +1,30 @@
+#
+# Jamfile (recycle_bin)
+#
+#
+# Original author: Darren Kessner <Darren.Kessner@...>
+#
+# Copyright 2008 Spielberg Family Center for Applied Proteomics
+#   Cedars-Sinai Medical Center, Los Angeles, California  90048
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); 
+# you may not use this file except in compliance with the License. 
+# You may obtain a copy of the License at 
+# 
+# http://www.apache.org/licenses/LICENSE-2.0
+# 
+# Unless required by applicable law or agreed to in writing, software 
+# distributed under the License is distributed on an "AS IS" BASIS, 
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+# See the License for the specific language governing permissions and 
+# limitations under the License.
+#
+
+
+
+unit-test PeptideDatabaseTest 
+    :   PeptideDatabase.cpp 
+        PeptideDatabaseTest.cpp 
+        /ext/boost//iostreams
+        /ext/boost//filesystem ;
+

Copied: trunk/pwiz/pwiz/utility/recycle_bin/PeptideDatabase.cpp (from rev 395, trunk/pwiz/pwiz/utility/proteome/PeptideDatabase.cpp)
===================================================================
--- trunk/pwiz/pwiz/utility/recycle_bin/PeptideDatabase.cpp	                        (rev 0)
+++ trunk/pwiz/pwiz/utility/recycle_bin/PeptideDatabase.cpp	2008-09-17 23:20:44 UTC (rev 397)
@@ -0,0 +1,318 @@
+//
+// PeptideDatabase.cpp 
+//
+//
+// Original author: Darren Kessner <Darren.Kessner@...>
+//
+// Copyright 2006 Louis Warschaw Prostate Cancer Center
+//   Cedars Sinai Medical Center, Los Angeles, California  90048
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License.
+//
+
+
+#define PWIZ_SOURCE
+
+#include "PeptideDatabase.hpp"
+#include "boost/iostreams/device/mapped_file.hpp"
+#include <iostream>
+#include <vector>
+#include <stdexcept>
+#include <fstream>
+
+
+namespace pwiz {
+namespace proteome {
+
+
+using namespace std;
+
+
+//
+//  The PeptideDatabase interface has two implementations:
+//
+//  1) PeptideDatabaseImpl_Memory is instantiated by PeptideDatabase::create(void).
+//     It is a writeable database that uses dynamic arrays internally.
+//     It can be written out to a binary file, which can be read by PeptideDatabaseImpl_File.
+//
+//  2) PeptideDatabaseImpl_File is instantiated by PeptideDatabase::create(filename).
+//     It is a read-only database that is backed by a binary file. 
+//     It uses the boost memory-mapped file objects, which abstract the different
+//     memory-mapped file facilities in Windows and POSIX. 
+//
+//  The binary file format was designed to have constant-size records, to allow for 
+//  efficient binary searches.  To accomodate variable-length amino acid sequences, 
+//  each PeptideDatabaseRecord has a sequenceKey, which is an offset into a string table.
+//  The string table follows the main records in the file.
+//
+//  pseudo_struct binary_file_format
+//  {
+//      PDBHeader header;
+//      PeptideDatabaseRecord records[header.recordCount];
+//      char stringTable[header.stringTableSize];
+//  };
+//
+
+
+PWIZ_API_DECL ostream& operator<<(ostream& os, const PeptideDatabaseFormula& formula)
+{
+    os << "C" << formula.C 
+        << " H" << formula.H
+        << " N" << formula.N
+        << " O" << formula.O
+        << " S" << formula.S;
+	
+	return os;
+}
+
+
+PWIZ_API_DECL bool operator==(const PeptideDatabaseFormula& r, const PeptideDatabaseFormula& s) 
+{
+    return (r.C == s.C &&
+            r.H == s.H &&
+            r.N == s.N &&
+            r.O == s.O &&
+            r.S == s.S);
+}
+
+
+PWIZ_API_DECL ostream& operator<<(ostream& os, const PeptideDatabaseRecord& record)
+{
+    os << record.abundance << " " << record.mass << " " << record.formula; 
+	return os;
+}
+
+
+#pragma pack(1)
+struct PDBHeader
+{
+    char magic[4]; // "PCC\0"
+    char type[4];  // "PDB\0" (Peptide DataBase)
+    int version;
+    int recordsOffset;
+    int recordCount;
+    int stringTableOffset;
+    int stringTableSize;
+
+    PDBHeader()
+    :   version(1), // increment here if format changes
+        recordsOffset(0),
+        recordCount(0),
+        stringTableOffset(0),
+        stringTableSize(0)
+    {
+        strncpy(magic, "PCC\0", 4);
+        strncpy(type, "PDB\0", 4);
+    }
+};
+#pragma pack()
+
+
+class PeptideDatabaseImpl_Memory : public PeptideDatabase 
+{
+    public:
+    PeptideDatabaseImpl_Memory();
+    virtual int size() const;
+    virtual const PeptideDatabaseRecord* records() const;
+    virtual string sequence(const PeptideDatabaseRecord& record) const;
+    virtual void append(const PeptideDatabaseRecord& record, const string& sequence);
+    virtual void write(const string& filename) const;
+
+    private:
+    vector<PeptideDatabaseRecord> records_;
+    string stringTable_;
+};
+
+
+PeptideDatabaseImpl_Memory::PeptideDatabaseImpl_Memory()
+{
+    stringTable_ += '\0'; // sequenceKey==0 -> null string
+}
+
+
+int PeptideDatabaseImpl_Memory::size() const 
+{
+    return (int)records_.size();
+}
+
+
+const PeptideDatabaseRecord* PeptideDatabaseImpl_Memory::records() const 
+{
+    if (records_.empty())
+        throw logic_error("[PeptideDatabaseImpl_Memory::records()]  No records.");
+    return &records_[0];
+} 
+
+
+string PeptideDatabaseImpl_Memory::sequence(const PeptideDatabaseRecord& record) const
+{
+    return string(stringTable_.data() + record.sequenceKey); 
+}
+
+
+void PeptideDatabaseImpl_Memory::append(const PeptideDatabaseRecord& record, const string& sequence)
+{
+    if (record.sequenceKey != 0) 
+        throw logic_error("[PeptideDatabaseImpl_Memory::append()] Non-zero sequenceKey."); 
+
+    records_.push_back(record);
+    
+    if (!sequence.empty())
+    {
+        PeptideDatabaseRecord& r = records_[records_.size()-1];
+        r.sequenceKey = (int)stringTable_.size(); 
+        stringTable_ += sequence + '\0';
+    }
+}
+
+
+void PeptideDatabaseImpl_Memory::write(const string& filename) const
+{
+    if (records_.empty())
+        throw logic_error("[PeptideDatabaseImpl_Memory::write()]  No records.");
+    
+    ofstream os(filename.c_str(), ios::binary);
+    if (!os)
+        throw runtime_error("[PeptideDatabaseImpl_Memory::write()] Unable to open file " + filename);
+    
+    PDBHeader header;
+    header.recordsOffset = sizeof(header);
+    header.recordCount = (int)records_.size();
+    header.stringTableOffset = header.recordsOffset + header.recordCount*sizeof(PeptideDatabaseRecord);
+    header.stringTableSize = (int)stringTable_.size();
+
+    os.write((const char*)&header, sizeof(header));
+    os.write((const char*)&records_[0], header.recordCount*sizeof(PeptideDatabaseRecord)); 
+    os.write(stringTable_.c_str(), (streamsize)stringTable_.size());
+}
+
+
+class PeptideDatabaseImpl_File : public PeptideDatabase 
+{
+    public:
+    PeptideDatabaseImpl_File(const string& filename);
+    virtual int size() const;
+    virtual const PeptideDatabaseRecord* records() const;
+    virtual string sequence(const PeptideDatabaseRecord& record) const;
+    virtual void append(const PeptideDatabaseRecord& record, const string& sequence);
+    virtual void write(const string& filename) const;
+
+    private:
+    boost::iostreams::mapped_file_source file_;
+    const PDBHeader* header_;
+    int recordCount_;
+    const PeptideDatabaseRecord* records_;
+    int stringTableSize_;
+    const char* stringTable_;
+};
+
+
+PeptideDatabaseImpl_File::PeptideDatabaseImpl_File(const string& filename)
+:   file_(filename), 
+    header_(0),
+    recordCount_(0), records_(0),
+    stringTableSize_(0), stringTable_(0)
+{
+    header_ = reinterpret_cast<const PDBHeader*>(file_.data());
+
+    PDBHeader good;
+    if (strncmp(header_->magic, good.magic, 4) ||
+        strncmp(header_->type, good.type, 4) ||
+        header_->version != good.version)
+        throw runtime_error("[PeptideDatabaseImpl_File::PeptideDatabaseImpl_File] '" + filename + "' has an invalid header.");
+
+    recordCount_ = header_->recordCount;
+    records_ = reinterpret_cast<const PeptideDatabaseRecord*>(file_.data() + header_->recordsOffset); 
+    stringTableSize_ = header_->stringTableSize;
+    stringTable_ = reinterpret_cast<const char*>(file_.data() + header_->stringTableOffset);
+}
+
+
+int PeptideDatabaseImpl_File::size() const
+{
+    return recordCount_; 
+}
+
+
+const PeptideDatabaseRecord* PeptideDatabaseImpl_File::records() const
+{
+    return records_; 
+}
+
+
+string PeptideDatabaseImpl_File::sequence(const PeptideDatabaseRecord& record) const
+{
+    return string(stringTable_ + record.sequenceKey);
+}
+
+
+void PeptideDatabaseImpl_File::append(const PeptideDatabaseRecord& record, const string& sequence)
+{
+    // this will never be called, since clients cannot obtain a non-const this
+    throw logic_error("PeptideDatabaseImpl_File::append() not implemented.");
+}
+
+
+void PeptideDatabaseImpl_File::write(const string& filename) const
+{
+    // this should never be needed
+    throw logic_error("PeptideDatabaseImpl_File::write() not implemented.");
+}
+
+
+PWIZ_API_DECL auto_ptr<PeptideDatabase> PeptideDatabase::create()
+{
+    return auto_ptr<PeptideDatabase>(new PeptideDatabaseImpl_Memory);
+}
+
+
+PWIZ_API_DECL auto_ptr<const PeptideDatabase> PeptideDatabase::create(const string& filename)
+{
+    try 
+    {
+        return auto_ptr<const PeptideDatabase>(new PeptideDatabaseImpl_File(filename));
+    }
+    catch (BOOST_IOSTREAMS_FAILURE&)
+    {
+        throw runtime_error("[PeptideDatabase::create()] Unable to map file " + filename); 
+    }
+}
+
+
+namespace {
+bool hasSmallerMass(const PeptideDatabaseRecord& a, const PeptideDatabaseRecord& b)
+{
+    return a.mass < b.mass;
+}
+} // namespace
+
+
+PWIZ_API_DECL PeptideDatabase::iterator PeptideDatabase::mass_lower_bound(double mass) const
+{
+    PeptideDatabaseRecord record;
+    record.mass = mass;
+    return lower_bound(begin(), end(), record, hasSmallerMass);
+}
+
+
+PWIZ_API_DECL PeptideDatabase::iterator PeptideDatabase::mass_upper_bound(double mass) const
+{
+    PeptideDatabaseRecord record;
+    record.mass = mass;
+    return upper_bound(begin(), end(), record, hasSmallerMass);
+}
+
+
+} // namespace proteome
+} // namespace pwiz
+

Copied: trunk/pwiz/pwiz/utility/recycle_bin/PeptideDatabase.hpp (from rev 395, trunk/pwiz/pwiz/utility/proteome/PeptideDatabase.hpp)
===================================================================
--- trunk/pwiz/pwiz/utility/recycle_bin/PeptideDatabase.hpp	                        (rev 0)
+++ trunk/pwiz/pwiz/utility/recycle_bin/PeptideDatabase.hpp	2008-09-17 23:20:44 UTC (rev 397)
@@ -0,0 +1,110 @@
+//
+// PeptideDatabase.hpp 
+//
+//
+// Original author: Darren Kessner <Darren.Kessner@...>
+//
+// Copyright 2006 Louis Warschaw Prostate Cancer Center
+//   Cedars Sinai Medical Center, Los Angeles, California  90048
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License.
+//
+
+
+#ifndef _PEPTIDEDATABASE_HPP_
+#define _PEPTIDEDATABASE_HPP_ 
+
+
+#include "utility/misc/Export.hpp"
+#include <string>
+#include <memory>
+
+
+namespace pwiz {
+namespace proteome {
+
+
+#pragma pack(1)
+struct PWIZ_API_DECL PeptideDatabaseFormula
+{
+    int C;
+    int H;
+    int N;
+    int O;
+    int S;
+
+    PeptideDatabaseFormula(int c=0, int h=0, int n=0, int o=0, int s=0)
+    :   C(c), H(h), N(n), O(o), S(s)
+    {}
+};
+#pragma pack()
+
+
+PWIZ_API_DECL std::ostream& operator<<(std::ostream& os, const PeptideDatabaseFormula& formula);
+
+
+#pragma pack(1)
+struct PWIZ_API_DECL PeptideDatabaseRecord
+{
+    int id_ipi;
+    double abundance;
+    double mass;
+    PeptideDatabaseFormula formula;
+    int sequenceKey;
+
+    PeptideDatabaseRecord()
+    :   id_ipi(0), abundance(1), mass(0), sequenceKey(0)
+    {}
+};
+#pragma pack()
+
+
+PWIZ_API_DECL std::ostream& operator<<(std::ostream& os, const PeptideDatabaseRecord& record);
+PWIZ_API_DECL bool operator==(const PeptideDatabaseFormula& r, const PeptideDatabaseFormula& s); 
+
+
+class PWIZ_API_DECL PeptideDatabase
+{
+    public:
+
+    static std::auto_ptr<PeptideDatabase> create();
+    static std::auto_ptr<const PeptideDatabase> create(const std::string& filename);
+    virtual ~PeptideDatabase(){}
+
+    virtual int size() const = 0;
+    virtual const PeptideDatabaseRecord* records() const = 0;
+    virtual std::string sequence(const PeptideDatabaseRecord& record) const = 0;
+
+    virtual void append(const PeptideDatabaseRecord& record, const std::string& sequence = "") = 0;
+    //virtual void append(const std::string& sequence) = 0;
+    virtual void write(const std::string& filename) const = 0;
+
+    // sortByMass() (rewriteStringTable)
+
+    // iterator interface
+    typedef const PeptideDatabaseRecord* iterator;
+    iterator begin() const {return records();}
+    iterator end() const {return records() + size();}
+
+    // range access (binary search algorithms assume database is sorted by mass)
+    iterator mass_lower_bound(double mass) const;
+    iterator mass_upper_bound(double mass) const;
+};
+
+
+} // namespace pwiz
+} // namespace proteome
+
+
+#endif // _PEPTIDEDATABASE_HPP_ 
+

Copied: trunk/pwiz/pwiz/utility/recycle_bin/PeptideDatabaseTest.cpp (from rev 395, trunk/pwiz/pwiz/utility/proteome/PeptideDatabaseTest.cpp)
===================================================================
--- trunk/pwiz/pwiz/utility/recycle_bin/PeptideDatabaseTest.cpp	                        (rev 0)
+++ trunk/pwiz/pwiz/utility/recycle_bin/PeptideDatabaseTest.cpp	2008-09-17 23:20:44 UTC (rev 397)
@@ -0,0 +1,141 @@
+//
+// PeptideDatabaseTest.cpp
+//
+//
+// Original author: Darren Kessner <Darren.Kessner@...>
+//
+// Copyright 2006 Louis Warschaw Prostate Cancer Center
+//   Cedars Sinai Medical Center, Los Angeles, California  90048
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); 
+// you may not use this file except in compliance with the License. 
+// You may obtain a copy of the License at 
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software 
+// distributed under the License is distributed on an "AS IS" BASIS, 
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
+// See the License for the specific language governing permissions and 
+// limitations under the License.
+//
+
+
+#include "PeptideDatabase.hpp"
+#include "utility/misc/unit.hpp"
+#include <boost/filesystem/operations.hpp>
+#include <iostream>
+
+
+using namespace std;
+using namespace pwiz::util;
+using namespace pwiz::proteome;
+
+
+ostream* os_ = 0;
+
+
+void compareRecords(const PeptideDatabase* pdb1, const PeptideDatabaseRecord* record1,
+                    const PeptideDatabase* pdb2, const PeptideDatabaseRecord* record2)
+{
+    unit_assert(record1->id_ipi == record2->id_ipi);
+    unit_assert(record1->abundance == record2->abundance);
+    unit_assert(record1->mass == record2->mass);
+    unit_assert(record1->formula == record2->formula);
+    unit_assert(pdb1->sequence(*record1) == pdb2->sequence(*record2));
+}
+
+
+void test_basic()
+{
+    auto_ptr<PeptideDatabase> pdb = PeptideDatabase::create();
+
+    PeptideDatabaseRecord record;
+
+    record.abundance = 10;
+    record.mass = 27;
+    record.formula = PeptideDatabaseFormula(1, 2, 3, 4, 5);
+    pdb->append(record, "darren");
+
+    record.abundance = 20;
+    record.mass = 666;
+    record.formula = PeptideDatabaseFormula(6, 7, 8, 9, 10);
+    pdb->append(record, "goo");
+
+    unit_assert(pdb->size()==2);
+   
+    const PeptideDatabaseRecord* p = pdb->records();
+    unit_assert(p->abundance == 10);
+    unit_assert(p->mass == 27);
+    unit_assert(p->formula.C == 1); 
+    unit_assert(pdb->sequence(*p) == "darren");
+    
+    p++;
+    unit_assert(p->abundance == 20);
+    unit_assert(p->mass == 666);
+    unit_assert(p->formula.C == 6);
+    unit_assert(p->formula.S == 10);
+    unit_assert(pdb->sequence(*p) == "goo");
+     
+    // iterator interface 
+    if (os_)
+        for (PeptideDatabase::iterator it=pdb->begin(); it!=pdb->end(); ++it) 
+            *os_ << *it << " " << pdb->sequence(*it) << endl;
+
+    // test i/o
+    string filename = "PeptideDatabaseTest.output.pdb";
+    {
+        pdb->write(filename);
+        auto_ptr<const PeptideDatabase> pdb2 = PeptideDatabase::create(filename);
+        unit_assert(pdb2->size() == pdb->size());
+      
+        for (int i=0; i<pdb->size(); ++i)
+        {
+            const PeptideDatabaseRecord* record1 = pdb->records()+i;
+            const PeptideDatabaseRecord* record2 = pdb2->records()+i;
+            compareRecords(pdb.get(), record1, pdb2.get(), record2);
+        }
+    }
+
+    boost::filesystem::remove(filename);
+}
+        
+        
+void test_range()
+{
+    auto_ptr<PeptideDatabase> pdb = PeptideDatabase::create();
+
+    for (int i=0; i<10; i++)
+    {
+        PeptideDatabaseRecord record;
+        record.mass = i;
+        pdb->append(record);
+    }
+
+    PeptideDatabase::iterator begin = pdb->begin();
+    PeptideDatabase::iterator six = pdb->mass_lower_bound(5.5);
+    PeptideDatabase::iterator eight = pdb->mass_upper_bound(7.5);
+    unit_assert(six == begin+6);
+    unit_assert(eight == begin+8);
+}
+
+
+int main(int argc, char* argv[])
+{
+
+    try
+    {
+        if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
+        if (os_) *os_ << "PeptideDatabaseTest\n";
+        test_basic();
+        test_range();
+        return 0;
+    }
+    catch (exception& e)
+    {
+        cerr << e.what() << endl;
+        return 1;
+    }
+}
+
+


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 424
          http://proteowizard.svn.sourceforge.net/proteowizard/?rev=424&view=rev
Author:   chambm
Date:     2008-10-14 22:27:18 +0000 (Tue, 14 Oct 2008)

Log Message:
-----------
- refactored sloppy (and broken) thread safety code in AminoAcid, Chemistry, and Peptide to use thread_specific_singleton
- added thread safety unit testing using boost::thread
- changed AminoAcid and Peptide unit tests to use average masses based on NIST/Unimod atomic weights
- changed unit_assert_equal to allow equality to epsilon (to support epsilon values of 0)

Modified Paths:
--------------
    trunk/pwiz/pwiz/utility/misc/unit.hpp
    trunk/pwiz/pwiz/utility/proteome/AminoAcid.cpp
    trunk/pwiz/pwiz/utility/proteome/AminoAcid.hpp
    trunk/pwiz/pwiz/utility/proteome/AminoAcidTest.cpp
    trunk/pwiz/pwiz/utility/proteome/Chemistry.cpp
    trunk/pwiz/pwiz/utility/proteome/Chemistry.hpp
    trunk/pwiz/pwiz/utility/proteome/ChemistryTest.cpp
    trunk/pwiz/pwiz/utility/proteome/Digestion.cpp
    trunk/pwiz/pwiz/utility/proteome/Peptide.cpp
    trunk/pwiz/pwiz/utility/proteome/PeptideTest.cpp

Modified: trunk/pwiz/pwiz/utility/misc/unit.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/misc/unit.hpp	2008-10-14 21:52:21 UTC (rev 423)
+++ trunk/pwiz/pwiz/utility/misc/unit.hpp	2008-10-14 22:27:18 UTC (rev 424)
@@ -66,7 +66,7 @@
 
 
 #define unit_assert_equal(x, y, epsilon) \
-    (!(fabs((x)-(y)) < (epsilon)) ? throw std::runtime_error(unit_assert_equal_message(__FILE__, __LINE__, (x), (y), (epsilon))) : 0)
+    (!(fabs((x)-(y)) <= (epsilon)) ? throw std::runtime_error(unit_assert_equal_message(__FILE__, __LINE__, (x), (y), (epsilon))) : 0)
 
 
 #define unit_assert_matrices_equal(A, B, epsilon) \

Modified: trunk/pwiz/pwiz/utility/proteome/AminoAcid.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/AminoAcid.cpp	2008-10-14 21:52:21 UTC (rev 423)
+++ trunk/pwiz/pwiz/utility/proteome/AminoAcid.cpp	2008-10-14 22:27:18 UTC (rev 424)
@@ -119,6 +119,7 @@
 
 
 PWIZ_API_DECL Info::Info() : impl_(new Impl) {}
+PWIZ_API_DECL Info::Info(boost::restricted) : impl_(new Impl) {}
 PWIZ_API_DECL Info::~Info() {} // automatic destruction of impl_
 PWIZ_API_DECL const Info::Record& Info::operator[](Type type) const {return impl_->record(type);}
 

Modified: trunk/pwiz/pwiz/utility/proteome/AminoAcid.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/AminoAcid.hpp	2008-10-14 21:52:21 UTC (rev 423)
+++ trunk/pwiz/pwiz/utility/proteome/AminoAcid.hpp	2008-10-14 22:27:18 UTC (rev 424)
@@ -29,6 +29,7 @@
 #include "Chemistry.hpp"
 #include <string>
 #include <memory>
+#include "boost/utility/thread_specific_singleton.hpp"
 
 
 namespace pwiz {
@@ -69,13 +70,15 @@
 
 
 /// class for accessing information about the amino acids
-class PWIZ_API_DECL Info 
+class PWIZ_API_DECL Info : public boost::thread_specific_singleton<Info>
 {
     public:
 
     Info();
     ~Info();
 
+    Info(boost::restricted);
+
     /// struct for holding data for a single amino acid
     struct Record 
     {

Modified: trunk/pwiz/pwiz/utility/proteome/AminoAcidTest.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/AminoAcidTest.cpp	2008-10-14 21:52:21 UTC (rev 423)
+++ trunk/pwiz/pwiz/utility/proteome/AminoAcidTest.cpp	2008-10-14 22:27:18 UTC (rev 424)
@@ -28,11 +28,14 @@
 #include <stdexcept>
 #include <functional>
 #include <algorithm>
+#include "boost/thread/thread.hpp"
+#include "boost/thread/barrier.hpp"
 
 
 using namespace std;
 using namespace pwiz::util;
 using namespace pwiz::proteome;
+using namespace pwiz::proteome::Chemistry;
 using namespace pwiz::proteome::Chemistry::Element;
 using namespace pwiz::proteome::AminoAcid;
 
@@ -50,16 +53,16 @@
 {
     if (!os) return;
 
-	Chemistry::Formula residueFormula = record.formula;
-    
     *os << record.symbol << ": " 
         << setw(14) << record.name << " " 
         << setw(11) << record.formula << " " 
         << setprecision(3)
         << setw(5) << record.abundance << " "
-        << fixed 
-        << setw(7) << record.formula.monoisotopicMass() << " "
-        << setw(7) << residueFormula.monoisotopicMass() << endl;
+        << fixed << setprecision(6)
+        << setw(10) << record.formula.monoisotopicMass() << " "
+        << setw(10) << record.formula.molecularWeight() << " "
+        << setw(10) << record.residueFormula.monoisotopicMass() << " "
+        << setw(10) << record.residueFormula.molecularWeight() << endl;
 }
 
 
@@ -70,31 +73,32 @@
     char symbol;
 };
 
+// masses copied from http://www.unimod.org/xml/unimod.xml
 TestAminoAcid testAminoAcids[] =
 {
-    { 71.03711, 71.07880, 'A' },    // Alanine
-    { 103.0092, 103.1388, 'C' },    // Cysteine
-    { 115.0269, 115.0886, 'D' },    // Aspartic acid
-    { 129.0426, 129.1155, 'E' },    // Glutamic acid
-    { 147.0684, 147.1766, 'F' },    // Phenylalanine
-    { 57.02146, 57.05190, 'G' },    // Glycine
-    { 137.0589, 137.1411, 'H' },    // Histidine
-    { 113.0841, 113.1594, 'I' },    // Isoleucine
-    { 128.0949, 128.1741, 'K' },    // Lysine
-    { 113.0841, 113.1594, 'L' },    // Leucine
-    { 131.0405, 131.1926, 'M' },    // Methionine
-    { 114.0429, 114.1038, 'N' },    // Asparagine
-    { 97.05276, 97.11670, 'P' },    // Proline
-    { 128.0586, 128.1307, 'Q' },    // Glutamine
-    { 156.1011, 156.1875, 'R' },    // Arginine
-    { 87.03203, 87.07820, 'S' },    // Serine
-    { 101.0477, 101.1051, 'T' },    // Threonine
-    { 186.0793, 186.2132, 'W' },    // Tryptophan
-    { 163.0633, 163.1760, 'Y' },    // Tyrosine
-    { 99.06841, 99.13260, 'V' },    // Valine
-    { 114.0429, 114.1038, 'B' },    // AspX
-    { 128.0586, 128.1307, 'Z' },    // GlutX
-    { 114.0919, 114.1674, 'X' }     // Unknown (Averagine)
+    { 71.0371140, 71.07790, 'A' },    // Alanine
+    { 156.101111, 156.1857, 'R' },    // Arginine
+    { 114.042927, 114.1026, 'N' },    // Asparagine
+    { 115.026943, 115.0874, 'D' },    // Aspartic acid
+    { 103.009185, 103.1429, 'C' },    // Cysteine
+    { 129.042593, 129.1140, 'E' },    // Glutamic acid
+    { 128.058578, 128.1292, 'Q' },    // Glutamine
+    { 57.0214640, 57.05130, 'G' },    // Glycine
+    { 137.058912, 137.1393, 'H' },    // Histidine
+    { 113.084064, 113.1576, 'I' },    // Isoleucine
+    { 113.084064, 113.1576, 'L' },    // Leucine
+    { 128.094963, 128.1723, 'K' },    // Lysine
+    { 131.040485, 131.1961, 'M' },    // Methionine
+    { 147.068414, 147.1739, 'F' },    // Phenylalanine
+    { 97.0527640, 97.11520, 'P' },    // Proline
+    { 87.0320280, 87.07730, 'S' },    // Serine
+    { 101.047679, 101.1039, 'T' },    // Threonine
+    { 186.079313, 186.2099, 'W' },    // Tryptophan
+    { 163.063329, 163.1733, 'Y' },    // Tyrosine
+    { 99.0684140, 99.13110, 'V' },    // Valine
+    { 114.042927, 114.1026, 'B' },    // AspX
+    { 128.058578, 128.1292, 'Z' },    // GlutX
+    { 114.091900, 114.1674, 'X' }     // Unknown (Averagine)
 };
 
 
@@ -102,6 +106,24 @@
 {
     AminoAcid::Info info;
 
+    // get a copy of all the records
+
+    vector<AminoAcid::Info::Record> records;
+
+    for (char symbol='A'; symbol<='Z'; symbol++)
+    {
+        try 
+        {
+            const AminoAcid::Info::Record& record = info[symbol];
+            records.push_back(record);
+        }
+        catch (exception&)
+        {}
+    }
+
+    for (vector<AminoAcid::Info::Record>::iterator it=records.begin(); it!=records.end(); ++it)
+        printRecord(os_, *it);
+
     unit_assert(info[Alanine].residueFormula[C] == 3);
     unit_assert(info[Alanine].residueFormula[H] == 5);
     unit_assert(info[Alanine].residueFormula[N] == 1);
@@ -120,8 +142,8 @@
     {
         TestAminoAcid& aa = testAminoAcids[i];
         Chemistry::Formula residueFormula = info[aa.symbol].residueFormula;
-        unit_assert_equal(residueFormula.monoisotopicMass(), aa.monoMass, 0.01);
-        unit_assert_equal(residueFormula.molecularWeight(), aa.avgMass, 0.01);
+        unit_assert_equal(residueFormula.monoisotopicMass(), aa.monoMass, 0.00001);
+        unit_assert_equal(residueFormula.molecularWeight(), aa.avgMass, 0.0001);
         //set<char> mmNames = mm2n.getNames(aa.monoMass, EPSILON);
         //set<char> amNames = am2n.getNames(aa.avgMass, EPSILON);
         //unit_assert(mmNames.count(aa.symbol) > 0);
@@ -129,21 +151,6 @@
     }
 
 
-    // get a copy of all the records
-
-    vector<AminoAcid::Info::Record> records;
-
-    for (char symbol='A'; symbol<='Z'; symbol++)
-    {
-        try 
-        {
-            const AminoAcid::Info::Record& record = info[symbol];
-            records.push_back(record);
-        }
-        catch (exception&)
-        {}
-    }
-
     // compute some averages
 
     double averageMonoisotopicMass = 0;
@@ -156,7 +163,6 @@
     for (vector<AminoAcid::Info::Record>::iterator it=records.begin(); it!=records.end(); ++it)
     {
         const AminoAcid::Info::Record& record = *it;
-        printRecord(os_, record);
 
         Chemistry::Formula residueFormula = record.residueFormula;
         averageMonoisotopicMass += residueFormula.monoisotopicMass() * record.abundance; 
@@ -186,6 +192,29 @@
 }
 
 
+void testThreadSafetyWorker(boost::barrier* testBarrier)
+{
+    testBarrier->wait(); // wait until all threads have started
+
+    // test thread-specific singleton access with instance
+    unit_assert(AminoAcid::Info::instance->operator[](Glycine).symbol == 'G');
+
+    // test thread-specific singleton access with lease
+    AminoAcid::Info::lease info;
+    unit_assert(info->operator[](Glycine).symbol == 'G');
+}
+
+void testThreadSafety()
+{
+    const int testThreadCount = 100;
+    boost::barrier testBarrier(testThreadCount);
+    boost::thread_group testThreadGroup;
+    for (int i=0; i < testThreadCount; ++i)
+        testThreadGroup.add_thread(new boost::thread(&testThreadSafetyWorker, &testBarrier));
+    testThreadGroup.join_all();
+}
+
+
 int main(int argc, char* argv[])
 {
     try
@@ -193,6 +222,7 @@
         if (argc>1 && !strcmp(argv[1],"-v")) os_ = &cout;
         if (os_) *os_ << "AminoAcidTest\n";
         test();
+        testThreadSafety();
         return 0;
     }
     catch (exception& e)

Modified: trunk/pwiz/pwiz/utility/proteome/Chemistry.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/Chemistry.cpp	2008-10-14 21:52:21 UTC (rev 423)
+++ trunk/pwiz/pwiz/utility/proteome/Chemistry.cpp	2008-10-14 22:27:18 UTC (rev 424)
@@ -35,6 +35,7 @@
 #include "utility/misc/String.hpp"
 #include "boost/thread/tss.hpp"
 
+//extern "C" void tss_cleanup_implemented() {} // workaround for TSS linker error?
 
 using namespace std;
 
@@ -88,55 +89,45 @@
     const Info::Record& record(Type type) const;
 
     private:
-    // keep only one copy of the data per thread
-    static boost::thread_specific_ptr< vector<Record> > data_;
+    vector<Record> data_;
     void initializeData();
 };
 
 
 Info::Impl::Impl() 
 {
+    //cout << "[Chemistry::Element::Info::initialize()]" << endl;
     initializeData();
 }
 
-
 const Info::Record& Info::Impl::record(Type type) const
 {
-    if (data_->size() < size_t(type))
+    if (data_.size() <= size_t(type))
         throw runtime_error("[Chemistry::Element::Info::Impl::record()]  Record not found.");
 
-    return (*data_)[type];
+    return data_[type];
 }
 
-
-boost::thread_specific_ptr< vector<Info::Record> > Info::Impl::data_;
-
-
 void Info::Impl::initializeData()
 {
-    if (!data_.get())
-    {
-        data_.reset(new vector<Info::Record>);
+    // iterate through the ChemistryData array and put it in our own data structure
+    ChemistryData::Element* it = ChemistryData::elements();
+    ChemistryData::Element* end = ChemistryData::elements() + ChemistryData::elementsSize();
 
-        // iterate through the ChemistryData array and put it in our own data structure
-        ChemistryData::Element* it = ChemistryData::elements();
-        ChemistryData::Element* end = ChemistryData::elements() + ChemistryData::elementsSize();
+    data_.resize(ChemistryData::elementsSize());
 
-        data_->resize(ChemistryData::elementsSize());
+    for (; it!=end; ++it)
+    {
+        Info::Record record;
+        record.type = it->type;
+        record.symbol = it->symbol;
+        record.atomicNumber = it->atomicNumber;
+        record.atomicWeight = it->atomicWeight;
+        
+        for (ChemistryData::Isotope* p=it->isotopes; p<it->isotopes+it->isotopesSize; ++p)
+            record.isotopes.push_back(MassAbundance(p->mass, p->abundance));        
 
-        for (; it!=end; ++it)
-        {
-            Info::Record record;
-            record.type = it->type;
-            record.symbol = it->symbol;
-            record.atomicNumber = it->atomicNumber;
-            record.atomicWeight = it->atomicWeight;
-            
-            for (ChemistryData::Isotope* p=it->isotopes; p<it->isotopes+it->isotopesSize; ++p)
-                record.isotopes.push_back(MassAbundance(p->mass, p->abundance));        
-
-            (*data_)[it->type] = record;        
-        }
+        data_[it->type] = record;        
     }
 }
 
@@ -144,6 +135,7 @@
 // Info implementation
 
 PWIZ_API_DECL Info::Info() : impl_(new Impl) {}
+PWIZ_API_DECL Info::Info(boost::restricted) : impl_(new Impl) {}
 PWIZ_API_DECL Info::~Info() {} // auto destruction of impl_
 PWIZ_API_DECL const Info::Record& Info::operator[](Type type) const {return impl_->record(type);}
 
@@ -191,8 +183,6 @@
 
 class Formula::Impl
 {
-    static auto_ptr<Element::Info> info_;
-
     public:
 
     Impl(const string& formula);
@@ -201,7 +191,7 @@
     {
         if (dirty)
         {
-            Element::Info& info = *info_;
+            Element::Info::lease info;
             dirty = false;
 
             monoMass = avgMass = 0;
@@ -210,7 +200,7 @@
                 int count = CHONSP_data[i];
                 if (count != 0)
                 {
-                    const Element::Info::Record& r = info[Element::Type(i)];
+                    const Element::Info::Record& r = info->operator[](Element::Type(i));
                     if (!r.isotopes.empty())
                         monoMass += r.isotopes[0].mass * count;
                     avgMass += r.atomicWeight * count;
@@ -219,7 +209,7 @@
 
             for (Data::const_iterator it=data.begin(); it!=data.end(); ++it)
             {
-                const Element::Info::Record& r = info[it->first];
+                const Element::Info::Record& r = info->operator[](it->first);
                 if (!r.isotopes.empty())
                     monoMass += r.isotopes[0].mass * it->second;
                 avgMass += r.atomicWeight * it->second;
@@ -235,7 +225,6 @@
     bool dirty; // true if masses need updating
 };
 
-auto_ptr<Element::Info> Formula::Impl::info_;
 
 Formula::Impl::Impl(const string& formula)
 :   monoMass(0), avgMass(0), dirty(false)
@@ -254,8 +243,7 @@
     const string& digits_ = "-0123456789";
     const string& letters_ = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
-    if (!info_.get()) info_.reset(new Element::Info);
-    Element::Info& info = *info_;
+    Element::Info::lease info;
 
     string::size_type index = 0;
     while (index < formula.size())
@@ -287,7 +275,7 @@
 
         index = formula.find_first_not_of(whitespace_, indexCountEnd);
 
-        const Element::Info::Record& r = info[type];
+        const Element::Info::Record& r = info->operator[](type);
         if (!r.isotopes.empty())
             monoMass += r.isotopes[0].mass * count;
         avgMass += r.atomicWeight * count;

Modified: trunk/pwiz/pwiz/utility/proteome/Chemistry.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/Chemistry.hpp	2008-10-14 21:52:21 UTC (rev 423)
+++ trunk/pwiz/pwiz/utility/proteome/Chemistry.hpp	2008-10-14 22:27:18 UTC (rev 424)
@@ -31,6 +31,7 @@
 #include <memory>
 #include <vector>
 #include "utility/misc/virtual_map.hpp"
+#include "boost/utility/thread_specific_singleton.hpp"
 
 
 namespace pwiz {
@@ -98,13 +99,15 @@
 
 
 /// class for obtaining information about elements
-class PWIZ_API_DECL Info
+class PWIZ_API_DECL Info : public boost::thread_specific_singleton<Info>
 {
     public:
 
     Info();
     ~Info();
 
+    Info(boost::restricted);
+
     /// structure for holding info about an element
     struct Record
     {

Modified: trunk/pwiz/pwiz/utility/proteome/ChemistryTest.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/ChemistryTest.cpp	2008-10-14 21:52:21 UTC (rev 423)
+++ trunk/pwiz/pwiz/utility/proteome/ChemistryTest.cpp	2008-10-14 22:27:18 UTC (rev 424)
@@ -29,11 +29,14 @@
 #include <iomanip>
 #include <stdexcept>
 #include <iterator>
+#include "boost/thread/thread.hpp"
+#include "boost/thread/barrier.hpp"
 
 
 using namespace std;
 using namespace pwiz::util;
 using namespace pwiz::proteome;
+using namespace Chemistry;
 
 
 ostream* os_ = 0;
@@ -41,7 +44,6 @@
 
 void testMassAbundance()
 {
-    using namespace Chemistry;
     MassAbundance ma(1, 2);
     MassAbundance ma2(1, 4);
     unit_assert(ma != ma2);
@@ -60,30 +62,31 @@
 
 const TestFormula testFormulaData[] =
 {
-    { "C1H2N3O4S5", 1, 2, 3, 4, 5, 279.864884, 280.374890 },
-    { "C1H 2N3O4 S5", 1, 2, 3, 4, 5, 279.864884, 280.374890 },
+    { "C1H2N3O4S5", 1, 2, 3, 4, 5, 279.864884, 280.36928 },
+    { "C1H 2N3O4 S5", 1, 2, 3, 4, 5, 279.864884, 280.36928 },
     { "H-42", 0, -42, 0, 0, 0, -42.328651, -42.333512 },
-    { "N2C-1", -1, 0, 2, 0, 0, 28.006148-12, 28.013486-12.010736 }
+    { "N2C-1", -1, 0, 2, 0, 0, 28.006148-12, 28.013486-12.0107 },
+    { "C39H67N11O10", 39, 67, 11, 10, 0, 849.507238, 850.01698 }
 };
 
 const int testFormulaDataSize = sizeof(testFormulaData)/sizeof(TestFormula);
 
 void testFormula()
 {
-    using namespace Chemistry;
-
     for (int i=0; i < testFormulaDataSize; ++i)
     {
         const TestFormula& testFormula = testFormulaData[i];
         Formula formula(testFormula.formula);
 
-        unit_assert(round(formula.monoisotopicMass()) == round(testFormula.monoMass));
-        unit_assert(round(formula.molecularWeight()) == round(testFormula.avgMass));
+        const double EPSILON = 0.001;
+
+        unit_assert_equal(formula.monoisotopicMass(), testFormula.monoMass, EPSILON);
+        unit_assert_equal(formula.molecularWeight(), testFormula.avgMass, EPSILON);
         if (os_) *os_ << formula << " " << formula.monoisotopicMass() << " " << formula.molecularWeight() << endl;
 
         formula[Element::C] += 2;
-        unit_assert(round(formula.monoisotopicMass()) == round(testFormula.monoMass+24));
-        unit_assert(round(formula.molecularWeight()) == round(testFormula.avgMass+24));
+        unit_assert_equal(formula.monoisotopicMass(), testFormula.monoMass+24, EPSILON);
+        unit_assert_equal(formula.molecularWeight(), testFormula.avgMass+12.0107*2, EPSILON);
         if (os_) *os_ << formula << " " << formula.monoisotopicMass() << " " << formula.molecularWeight() << endl;
 
         //const Formula& constFormula = formula;
@@ -92,14 +95,14 @@
         // test copy constructor and operator!=
         Formula formula2 = formula;
         formula2[Element::C] -= 2;
-        unit_assert(round(formula.monoisotopicMass()) == round(testFormula.monoMass+24));
-        unit_assert(round(formula2.monoisotopicMass()) == round(testFormula.monoMass));
+        unit_assert_equal(formula.monoisotopicMass(), testFormula.monoMass+24, EPSILON);
+        unit_assert_equal(formula2.monoisotopicMass(), testFormula.monoMass, EPSILON);
         if (os_) *os_ << "formula: " << formula << endl;
         if (os_) *os_ << "formula2: " << formula2 << endl;
 
         // test operator= and operator==
         formula2 = formula;
-        unit_assert(round(formula.monoisotopicMass()) == round(formula2.monoisotopicMass()));
+        unit_assert_equal(formula.monoisotopicMass(), formula2.monoisotopicMass(), EPSILON);
         if (os_) *os_ << "formula: " << formula << endl;
         if (os_) *os_ << "formula2: " << formula2 << endl;
 
@@ -118,8 +121,7 @@
 
 void testFormulaOperations()
 {
-    using namespace Chemistry; 
-    using namespace Element; 
+    using namespace Element;
 
     Formula water("H2O1");
     Formula a("C1 H2 N3 O4 S5");
@@ -142,7 +144,6 @@
 
 void testInfo()
 {
-    using namespace Chemistry;
     Element::Info info;
 
     if (os_)
@@ -156,23 +157,18 @@
 
 void infoExample()
 {
-    using namespace Chemistry;
-    using namespace Element;
-
-    Info info;
+    Element::Info info;
    
     if (os_)
     {
-        *os_ << "Sulfur isotopes: " << info[S].isotopes.size() << endl
-             << info[S].isotopes;
+        *os_ << "Sulfur isotopes: " << info[Element::S].isotopes.size() << endl
+             << info[Element::S].isotopes;
     }
 }
 
 
 void testPolysiloxane()
 {
-    using namespace Chemistry;
-
     Formula formula("Si6C12H36O6");
 
     if (os_) 
@@ -186,6 +182,29 @@
 }
 
 
+void testThreadSafetyWorker(boost::barrier* testBarrier)
+{
+    testBarrier->wait(); // wait until all threads have started
+
+    // test thread-specific singleton access with instance
+    unit_assert_equal(Element::Info::instance->operator[](Element::C).atomicNumber, 6.0, 0);
+
+    // test thread-specific singleton access with lease
+    Element::Info::lease info;
+    unit_assert_equal(info->operator[](Element::C).atomicNumber, 6.0, 0);
+}
+
+void testThreadSafety()
+{
+    const int testThreadCount = 100;
+    boost::barrier testBarrier(testThreadCount);
+    boost::thread_group testThreadGroup;
+    for (int i=0; i < testThreadCount; ++i)
+        testThreadGroup.add_thread(new boost::thread(&testThreadSafetyWorker, &testBarrier));
+    testThreadGroup.join_all();
+}
+
+
 int main(int argc, char* argv[])
 {
 
@@ -199,6 +218,7 @@
         testInfo();
         infoExample();
         testPolysiloxane();
+        testThreadSafety();
         return 0;
     }
     catch (exception& e)

Modified: trunk/pwiz/pwiz/utility/proteome/Digestion.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/Digestion.cpp	2008-10-14 21:52:21 UTC (rev 423)
+++ trunk/pwiz/pwiz/utility/proteome/Digestion.cpp	2008-10-14 22:27:18 UTC (rev 424)
@@ -133,13 +133,10 @@
 
 class Digestion::Motif::Impl
 {
-    //static auto_ptr<AminoAcid::Info> info_;
-
     public:
     Impl(const string& motif)
         :   motif_(motif)
     {
-        //if (!info_.get()) info_.reset(new AminoAcid::Info);
         parseMotif();
     }
 
@@ -189,7 +186,6 @@
     private:
     inline void parseMotif()
     {
-        //AminoAcid::Info& info = *info_;
         vector<char> multiResidueBlock;
 		int multiResidueBlockMode = 0; // 0=off 1=contained residues are included 2=contained residues are excluded
         bool parsedSiteDelimiter = false;
@@ -277,9 +273,7 @@
     vector<IsValidAA> cFilters_;
 };
 
-//auto_ptr<AminoAcid::Info> Digestion::Motif::Impl::info_;
 
-
 PWIZ_API_DECL
 Digestion::Motif::Motif(const string& motif)
 :   impl_(new Impl(motif))

Modified: trunk/pwiz/pwiz/utility/proteome/Peptide.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/Peptide.cpp	2008-10-14 21:52:21 UTC (rev 423)
+++ trunk/pwiz/pwiz/utility/proteome/Peptide.cpp	2008-10-14 22:27:18 UTC (rev 424)
@@ -29,7 +29,7 @@
 #include <iostream>
 #include <climits>
 #include "utility/misc/Exception.hpp"
-#include "boost/thread/tss.hpp"
+#include "boost/utility/thread_specific_singleton.hpp"
 
 extern "C" void tss_cleanup_implemented() {} // workaround for TSS linker error?
 
@@ -43,8 +43,6 @@
 
 class Peptide::Impl
 {
-    static boost::thread_specific_ptr<AminoAcid::Info> info_;
-
     public:
 
     Impl(Peptide* peptide, const std::string& sequence)
@@ -83,6 +81,10 @@
         }
     }
 
+    ~Impl()
+    {
+    }
+
     inline const string& sequence() const
     {
         return sequence_;
@@ -92,7 +94,7 @@
     {
         const static Formula H1("H1");
         const static Formula O1H1("O1H1");
-        AminoAcid::Info& info = *info_;
+        AminoAcid::Info::lease info;
         Formula formula;
 
         ModificationMap::const_iterator modItr = mods_.begin();
@@ -114,7 +116,7 @@
 
         for (size_t i=0, end=sequence_.length(); i < end; ++i)
         {
-            formula += info[sequence_[i]].residueFormula; // add AA residue formula
+            formula += info->operator[](sequence_[i]).residueFormula; // add AA residue formula
 
             // add modification formulae
             if (modified && modItr != mods_.end() && modItr->first == (int) i)
@@ -177,14 +179,12 @@
 
     inline void calculateMasses()
     {
-        if (!info_.get()) info_.reset(new AminoAcid::Info);
         Formula unmodifiedFormula = formula(false);
         monoMass_ = unmodifiedFormula.monoisotopicMass();
         avgMass_ = unmodifiedFormula.molecularWeight();
     }
 };
 
-boost::thread_specific_ptr<AminoAcid::Info> Peptide::Impl::info_;
 
 PWIZ_API_DECL Peptide::Peptide(const string& sequence) : impl_(new Impl(this, sequence)) {}
 PWIZ_API_DECL Peptide::Peptide(const char* sequence) : impl_(new Impl(this, sequence)) {}
@@ -258,41 +258,19 @@
 {
     public:
     Impl(const Peptide& peptide, bool mono, bool modified)
-        :   NTerminalDeltaMass(0), CTerminalDeltaMass(0),
-            aMass(mono ? aMonoMass : aAvgMass),
-            bMass(mono ? bMonoMass : bAvgMass),
-            cMass(mono ? cMonoMass : cAvgMass),
-            xMass(mono ? xMonoMass : xAvgMass),
-            yMass(mono ? yMonoMass : yAvgMass),
-            zMass(mono ? zMonoMass : zAvgMass)
+        :   NTerminalDeltaMass(0), CTerminalDeltaMass(0)
     {
-        if (aFormula.formula().empty())
-        {
-            aFormula = Formula("C-1O-1");
-            bFormula = Formula(""); // proton only
-            cFormula = Formula("N1H3");
-            xFormula = Formula("C1O1H-2") + Formula("H2O1");
-            yFormula = Formula("H2O1");
-            zFormula = Formula("N-1H-3") + Formula("H2O1");
+        StaticData::lease staticData;
+        aMass = (mono ? staticData->aFormula.monoisotopicMass() : staticData->aFormula.molecularWeight());
+        bMass = (mono ? staticData->bFormula.monoisotopicMass() : staticData->bFormula.molecularWeight());
+        cMass = (mono ? staticData->cFormula.monoisotopicMass() : staticData->cFormula.molecularWeight());
+        xMass = (mono ? staticData->xFormula.monoisotopicMass() : staticData->xFormula.molecularWeight());
+        yMass = (mono ? staticData->yFormula.monoisotopicMass() : staticData->yFormula.molecularWeight());
+        zMass = (mono ? staticData->zFormula.monoisotopicMass() : staticData->zFormula.molecularWeight());
 
-            aMonoMass = aFormula.monoisotopicMass();
-            bMonoMass = bFormula.monoisotopicMass();
-            cMonoMass = cFormula.monoisotopicMass();
-            xMonoMass = xFormula.monoisotopicMass();
-            yMonoMass = yFormula.monoisotopicMass();
-            zMonoMass = zFormula.monoisotopicMass();
-
-            aAvgMass = aFormula.molecularWeight();
-            bAvgMass = bFormula.molecularWeight();
-            cAvgMass = cFormula.molecularWeight();
-            xAvgMass = xFormula.molecularWeight();
-            yAvgMass = yFormula.molecularWeight();
-            zAvgMass = zFormula.molecularWeight();
-        }
-
         const string& sequence = peptide.sequence();
         maxLength = sequence.length();
-        AminoAcid::Info info;
+        AminoAcid::Info::lease info;
 
         const ModificationMap& mods = peptide.modifications();
         ModificationMap::const_iterator modItr = mods.begin();
@@ -312,7 +290,7 @@
         masses.resize(maxLength, 0);
         for (size_t i=0, end=maxLength; i < end; ++i)
         {
-            const Formula& f = info[sequence[i]].residueFormula;
+            const Formula& f = info->operator[](sequence[i]).residueFormula;
             mass += (mono ? f.monoisotopicMass() : f.molecularWeight());
             if (modified && modItr != mods.end() && modItr->first == (int) i)
             {
@@ -338,6 +316,14 @@
         }
     }
 
+    Impl(const Impl& other)
+    {
+    }
+
+    ~Impl()
+    {
+    }
+
     inline double a(size_t length, size_t charge) const
     {
         return charge == 0 ? NTerminalDeltaMass+f(length)+aMass
@@ -382,26 +368,32 @@
 
     double NTerminalDeltaMass;
     double CTerminalDeltaMass;
-    double& aMass;
-    double& bMass;
-    double& cMass;
-    double& xMass;
-    double& yMass;
-    double& zMass;
+    double aMass;
+    double bMass;
+    double cMass;
+    double xMass;
+    double yMass;
+    double zMass;
 
-    static Chemistry::Formula aFormula;
-    static Chemistry::Formula bFormula;
-    static Chemistry::Formula cFormula;
-    static Chemistry::Formula xFormula;
-    static Chemistry::Formula yFormula;
-    static Chemistry::Formula zFormula;
+    struct StaticData : public boost::thread_specific_singleton<StaticData>
+    {
+        StaticData(boost::restricted)
+        {
+            aFormula = Formula("C-1O-1");
+            bFormula = Formula(""); // proton only
+            cFormula = Formula("N1H3");
+            xFormula = Formula("C1O1H-2") + Formula("H2O1");
+            yFormula = Formula("H2O1");
+            zFormula = Formula("N-1H-3") + Formula("H2O1");
+        }
 
-    static double aMonoMass, aAvgMass;
-    static double bMonoMass, bAvgMass;
-    static double cMonoMass, cAvgMass;
-    static double xMonoMass, xAvgMass;
-    static double yMonoMass, yAvgMass;
-    static double zMonoMass, zAvgMass;
+        Chemistry::Formula aFormula;
+        Chemistry::Formula bFormula;
+        Chemistry::Formula cFormula;
+        Chemistry::Formula xFormula;
+        Chemistry::Formula yFormula;
+        Chemistry::Formula zFormula;
+    };
 };
 
 PWIZ_API_DECL
@@ -419,27 +411,6 @@
 
 PWIZ_API_DECL Fragmentation::~Fragmentation() {}
 
-Chemistry::Formula Fragmentation::Impl::aFormula;
-Chemistry::Formula Fragmentation::Impl::bFormula;
-Chemistry::Formula Fragmentation::Impl::cFormula;
-Chemistry::Formula Fragmentation::Impl::xFormula;
-Chemistry::Formula Fragmentation::Impl::yFormula;
-Chemistry::Formula Fragmentation::Impl::zFormula;
-
-double Fragmentation::Impl::aMonoMass;
-double Fragmentation::Impl::bMonoMass;
-double Fragmentation::Impl::cMonoMass;
-double Fragmentation::Impl::xMonoMass;
-double Fragmentation::Impl::yMonoMass;
-double Fragmentation::Impl::zMonoMass;
-
-double Fragmentation::Impl::aAvgMass;
-double Fragmentation::Impl::bAvgMass;
-double Fragmentation::Impl::cAvgMass;
-double Fragmentation::Impl::xAvgMass;
-double Fragmentation::Impl::yAvgMass;
-double Fragmentation::Impl::zAvgMass;
-
 PWIZ_API_DECL double Fragmentation::a(size_t length, size_t charge) const
 {
     return impl_->a(length, charge);

Modified: trunk/pwiz/pwiz/utility/proteome/PeptideTest.cpp
===================================================================
--- trunk/pwiz/pwiz/utility/proteome/PeptideTest.cpp	2008-10-14 21:52:21 UTC (rev 423)
+++ trunk/pwiz/pwiz/utility/proteome/PeptideTest.cpp	2008-10-14 22:27:18 UTC (rev 424)
@@ -27,7 +27,9 @@
 #include <iostream>
 #include <iomanip>
 #include <algorithm>
-#include "utility/misc/String.hpp"
+#include "utility/misc/String.hpp"
+#include "boost/thread/thread.hpp"
+#include "boost/thread/barrier.hpp"
 
 
 using namespace std;
@@ -89,10 +91,10 @@
 
 TestPeptide testPeptides[] =
 {
-    { "ELK", 388.2322, 389.24005, 195.12396, 388.4643, 389.4723, 195.2401 },
-    { "DEERLICKER", 1289.6398, 1290.6477, 645.8278, 1290.4571, 1291.465, 646.2365 },
-    { "ELVISLIVES", 1100.6329, 1101.6408, 551.3243, 1101.3056, 1102.3135, 551.6607 },
-    { "THEQICKRWNFMPSVERTHELAYDG", 3046.4178, 3047.4257, 1524.2168, 3048.4004, 3049.4083, 1525.2082 },
+    { "ELK", 388.2322, 389.24005, 195.12396, 388.45918, 389.4665, 195.2369 },
+    { "DEERLICKER", 1289.6398, 1290.6477, 645.8278, 1290.44644, 1291.4537, 646.2305 },
+    { "ELVISLIVES", 1100.6329, 1101.6408, 551.3243, 1101.29052, 1102.2978, 551.6525 },
+    { "THEQICKRWNFMPSVERTHELAYDG", 3046.4178, 3047.4257, 1524.2168, 3048.37046, 3049.3777, 1525.1925 },
     //{ "(THEQICKBRWNFXMPSVERTHELAZYDG)", 3402.5874, 3404.7792 }
 };
 
@@ -103,7 +105,7 @@
     for (size_t i=0; i < testPeptidesSize; ++i)
     {
         const TestPeptide& p = testPeptides[i];
-        double BIG_EPSILON = 0.05;
+        double BIG_EPSILON = 0.001;
 
         Peptide peptide(p.sequence);
         if (os_) *os_ << peptide.sequence() << ": " << peptide.formula() <<
@@ -163,54 +165,54 @@
     // M+16
     { "MEERKAT",
       "0 0",
-      879.41205, 879.98369
+      879.41205, 879.97844
     },
 
     // C+57
     { "THEQICKRWNFMPSVERTHELAYDG",
       "1 5",
-      3103.43929, 3105.45241
+      3103.43929, 3105.4218
     },
 
     // C+57, M+16
     { "THEQICKRWNFMPSVERTHELAYDG",
       "0 11 1 5",
-      3119.43419, 3121.45181
+      3119.43419, 3121.4212
     },
 
     // C+57, Q-17
     { "QICKRWNFMPSVERTHELAYDG",
       "2 0 1 2",
-      2719.26356, 2721.06016
+      2719.26356, 2721.0341
     },
 
     // no mods
-    { "ELVISLIVES", 0, 1100.63293, 1101.30557 },
+    { "ELVISLIVES", 0, 1100.63293, 1101.29052 },
 
     // E-17
     { "ELVISLIVES",
       "3 0",
-      1083.60638, 1084.27497
+      1083.60638, 1084.26
     },
 
     // no mods
-    { "PINGPNG", 0, 667.32898, 667.71964 },
+    { "PINGPNG", 0, 667.32898, 667.7112 },
 
     // N-17
     { "PINGPNG",
       "4 2",
-      650.30243, 650.68904
+      650.30243, 650.6807
     },
 
     //{ "(QINT)",,}, // Q-17
 
     // no mods
-    { "MISSISSIPPI", 0, 1143.62099, 1144.3918 },
+    { "MISSISSIPPI", 0, 1143.62099, 1144.3815 },
 
     // S+80, S+80
     { "MISSISSIPPI",
       "5 3 5 5",
-      1303.55365, 1304.3516
+      1303.55365, 1304.3413
     }
 };
 
@@ -246,7 +248,7 @@
         if (os_) *os_ << peptide.sequence() << ": " << peptide.monoisotopicMass() << " " << peptide.molecularWeight() << endl;
         if (os_) *os_ << peptide2.sequence() << ": " << peptide2.monoisotopicMass() << " " << peptide2.molecularWeight() << endl;
 
-        double BIG_EPSILON = 0.05;
+        double BIG_EPSILON = 0.001;
 
         unit_assert_equal(peptide.formula(true).monoisotopicMass(), p.monoMass, BIG_EPSILON);
         unit_assert_equal(peptide.formula(true).molecularWeight(), p.avgMass, BIG_EPSILON);
@@ -501,6 +503,25 @@
 }
 
 
+void testThreadSafetyWorker(boost::barrier* testBarrier)
+{
+    testBarrier->wait(); // wait until all threads have started
+
+    peptideTest();
+    fragmentTest();
+}
+
+void testThreadSafety()
+{
+    const int testThreadCount = 100;
+    boost::barrier testBarrier(testThreadCount);
+    boost::thread_group testThreadGroup;
+    for (int i=0; i < testThreadCount; ++i)
+        testThreadGroup.add_thread(new boost::thread(&testThreadSafetyWorker, &testBarrier));
+    testThreadGroup.join_all();
+}
+
+
 int main(int argc, char* argv[])
 {
     try
@@ -512,6 +533,7 @@
         peptideTest();
         modificationTest();
         fragmentTest();
+        testThreadSafety();
         return 0;
     }
     catch (exception& e)


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 610
          http://proteowizard.svn.sourceforge.net/proteowizard/?rev=610&view=rev
Author:   dkessner
Date:     2009-01-19 22:46:34 +0000 (Mon, 19 Jan 2009)

Log Message:
-----------
removed utility/recycle_bin

Modified Paths:
--------------
    trunk/pwiz/pwiz/utility/Jamfile.jam

Removed Paths:
-------------
    trunk/pwiz/pwiz/utility/recycle_bin/

Modified: trunk/pwiz/pwiz/utility/Jamfile.jam
===================================================================
--- trunk/pwiz/pwiz/utility/Jamfile.jam	2009-01-19 18:45:26 UTC (rev 609)
+++ trunk/pwiz/pwiz/utility/Jamfile.jam	2009-01-19 22:46:34 UTC (rev 610)
@@ -27,5 +27,4 @@
 build-project proteome ;
 build-project vendor_api ;
 build-project bindings ;
-build-project recycle_bin ;
 


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2442
          http://proteowizard.svn.sourceforge.net/proteowizard/?rev=2442&view=rev
Author:   chambm
Date:     2010-12-31 20:25:27 +0000 (Fri, 31 Dec 2010)

Log Message:
-----------
- fixed unqualified lexical_cast
- fixed out of order member initialization warnings

Modified Paths:
--------------
    trunk/pwiz/pwiz/utility/minimxml/XMLWriter.hpp
    trunk/pwiz/pwiz/utility/misc/IterationListener.hpp

Modified: trunk/pwiz/pwiz/utility/minimxml/XMLWriter.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/minimxml/XMLWriter.hpp	2010-12-31 20:09:43 UTC (rev 2441)
+++ trunk/pwiz/pwiz/utility/minimxml/XMLWriter.hpp	2010-12-31 20:25:27 UTC (rev 2442)
@@ -29,6 +29,7 @@
 #include "boost/shared_ptr.hpp"
 #include "boost/iostreams/positioning.hpp"
 #include "boost/iostreams/filter/counter.hpp"
+#include "boost/lexical_cast.hpp"
 #include <iosfwd>
 #include <string>
 #include <vector>
@@ -83,7 +84,7 @@
         template <typename T>
         inline void add(const std::string& name, const T& value)
         {
-            push_back(make_pair(name, lexical_cast<std::string>(value)));
+            push_back(make_pair(name, boost::lexical_cast<std::string>(value)));
         }
     };
 

Modified: trunk/pwiz/pwiz/utility/misc/IterationListener.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/misc/IterationListener.hpp	2010-12-31 20:09:43 UTC (rev 2441)
+++ trunk/pwiz/pwiz/utility/misc/IterationListener.hpp	2010-12-31 20:25:27 UTC (rev 2442)
@@ -43,9 +43,9 @@
 
     struct UpdateMessage
     {
-        const std::string& message;
         size_t iterationIndex;
         size_t iterationCount; // 0 == unknown
+        const std::string& message;
 
         UpdateMessage(size_t index, size_t count, const std::string& message = std::string()) 
         :   iterationIndex(index), iterationCount(count), message(message)


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 4131
          http://proteowizard.svn.sourceforge.net/proteowizard/?rev=4131&view=rev
Author:   chambm
Date:     2012-11-20 20:09:49 +0000 (Tue, 20 Nov 2012)
Log Message:
-----------
- added missing include for MSVC
- removed conflicting build requirement of pwiz_utility_math for darwin (that requirement is already correctly covered by a project-level requirement in Jamroot.jam)

Modified Paths:
--------------
    trunk/pwiz/pwiz/utility/math/Jamfile.jam
    trunk/pwiz/pwiz/utility/misc/unit.hpp

Modified: trunk/pwiz/pwiz/utility/math/Jamfile.jam
===================================================================
--- trunk/pwiz/pwiz/utility/math/Jamfile.jam	2012-11-20 19:09:21 UTC (rev 4130)
+++ trunk/pwiz/pwiz/utility/math/Jamfile.jam	2012-11-20 20:09:49 UTC (rev 4131)
@@ -30,7 +30,6 @@
                                         # (boost/numeric/ublas/traits.hpp)
         <toolset>msvc:<cxxflags>/wd4702 # warning: unreachable code
                                         # (boost/numeric/ublas/banded.hpp)
-        <toolset>darwin:<variant>debug  # ublas lu_factorize() causes bus error in release (inlining?)
         <toolset>msvc,<link>shared:<define>PWIZ_DYN_LINK
     ;
 

Modified: trunk/pwiz/pwiz/utility/misc/unit.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/misc/unit.hpp	2012-11-20 19:09:21 UTC (rev 4130)
+++ trunk/pwiz/pwiz/utility/misc/unit.hpp	2012-11-20 20:09:49 UTC (rev 4131)
@@ -28,6 +28,7 @@
 #include "Exception.hpp"
 #include "DateTime.hpp"
 #include "Filesystem.hpp"
+#include "pwiz/utility/math/round.hpp"
 #include <string>
 #include <sstream>
 #include <cmath>

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 4137
          http://proteowizard.svn.sourceforge.net/proteowizard/?rev=4137&view=rev
Author:   chambm
Date:     2012-11-21 22:21:32 +0000 (Wed, 21 Nov 2012)
Log Message:
-----------
- added escaping of special characters in TeamCity messages

Modified Paths:
--------------
    trunk/pwiz/pwiz/utility/bindings/CLI/common/unit.hpp
    trunk/pwiz/pwiz/utility/misc/unit.hpp

Modified: trunk/pwiz/pwiz/utility/bindings/CLI/common/unit.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/bindings/CLI/common/unit.hpp	2012-11-21 21:17:24 UTC (rev 4136)
+++ trunk/pwiz/pwiz/utility/bindings/CLI/common/unit.hpp	2012-11-21 22:21:32 UTC (rev 4137)
@@ -141,15 +141,28 @@
 
 // the following macros are used by the ProteoWizard tests to report test status and duration to TeamCity
 
+inline std::string escape_teamcity_string(const std::string& str)
+{
+    string result = str;
+    bal::replace_all(result, "'", "|'");
+    bal::replace_all(result, "\n", "|n");
+    bal::replace_all(result, "\r", "|r");
+    bal::replace_all(result, "|", "||");
+    bal::replace_all(result, "[", "|[");
+    bal::replace_all(result, "]", "|]");
+    return result;
+}
+
 #define TEST_PROLOG_EX(argc, argv, suffix) \
-    bfs::path testName = bfs::change_extension(bfs::basename(__FILE__), (suffix)); \
+    bfs::path testName = bfs::change_extension(bfs::basename(argv[0]), (suffix)); \
+    string teamcityTestName = escape_teamcity_string(testName.string()); \
     bpt::ptime testStartTime; \
     vector<string> testArgs(argv, argv+argc); \
     bool teamcityTestDecoration = find(testArgs.begin(), testArgs.end(), "--teamcity-test-decoration") != testArgs.end(); \
     if (teamcityTestDecoration) \
     { \
         testStartTime = bpt::microsec_clock::local_time(); \
-        cout << "##teamcity[testStarted name='" << testName << "']\n"; \
+        cout << "##teamcity[testStarted name='" << teamcityTestName << "']" << endl; \
     } \
     int testExitStatus = 0;
 
@@ -157,13 +170,13 @@
 
 #define TEST_FAILED(x) \
     if (teamcityTestDecoration) \
-        cout << "##teamcity[testFailed name='" << testName << "' message='" << (x) << "']\n"; \
+        cout << "##teamcity[testFailed name='" << teamcityTestName << "' message='" << escape_teamcity_string((x)) << "']\n"; \
     cerr << (x) << endl; \
     testExitStatus = 1;
 
 #define TEST_EPILOG \
     if (teamcityTestDecoration) \
-        cout << "##teamcity[testFinished name='" << testName << \
+        cout << "##teamcity[testFinished name='" << teamcityTestName << \
                 "' duration='" << round((bpt::microsec_clock::local_time() - testStartTime).total_microseconds() / 1000.0) << "']" << endl; \
     TerminateProcess(GetCurrentProcess(), testExitStatus); // HACK: avoid "Invalid string binding" crash at exit (probably a conflict between Boost and the .NET vendor DLLs)
 

Modified: trunk/pwiz/pwiz/utility/misc/unit.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/misc/unit.hpp	2012-11-21 21:17:24 UTC (rev 4136)
+++ trunk/pwiz/pwiz/utility/misc/unit.hpp	2012-11-21 22:21:32 UTC (rev 4137)
@@ -130,15 +130,28 @@
 
 // the following macros are used by the ProteoWizard tests to report test status and duration to TeamCity
 
+inline std::string escape_teamcity_string(const std::string& str)
+{
+    string result = str;
+    bal::replace_all(result, "'", "|'");
+    bal::replace_all(result, "\n", "|n");
+    bal::replace_all(result, "\r", "|r");
+    bal::replace_all(result, "|", "||");
+    bal::replace_all(result, "[", "|[");
+    bal::replace_all(result, "]", "|]");
+    return result;
+}
+
 #define TEST_PROLOG_EX(argc, argv, suffix) \
     bfs::path testName = bfs::change_extension(bfs::basename(argv[0]), (suffix)); \
+    string teamcityTestName = escape_teamcity_string(testName.string()); \
     bpt::ptime testStartTime; \
     vector<string> testArgs(argv, argv+argc); \
     bool teamcityTestDecoration = find(testArgs.begin(), testArgs.end(), "--teamcity-test-decoration") != testArgs.end(); \
     if (teamcityTestDecoration) \
     { \
         testStartTime = bpt::microsec_clock::local_time(); \
-        cout << "##teamcity[testStarted name='" << testName << "']" << endl; \
+        cout << "##teamcity[testStarted name='" << teamcityTestName << "']" << endl; \
     } \
     int testExitStatus = 0;
 
@@ -146,13 +159,13 @@
 
 #define TEST_FAILED(x) \
     if (teamcityTestDecoration) \
-        cout << "##teamcity[testFailed name='" << testName << "' message='" << (x) << "']\n"; \
+        cout << "##teamcity[testFailed name='" << teamcityTestName << "' message='" << escape_teamcity_string((x)) << "']\n"; \
     cerr << (x) << endl; \
     testExitStatus = 1;
 
 #define TEST_EPILOG \
     if (teamcityTestDecoration) \
-        cout << "##teamcity[testFinished name='" << testName << \
+        cout << "##teamcity[testFinished name='" << teamcityTestName << \
                 "' duration='" << round((bpt::microsec_clock::local_time() - testStartTime).total_microseconds() / 1000.0) << "']" << endl; \
     return testExitStatus;
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 4138
          http://proteowizard.svn.sourceforge.net/proteowizard/?rev=4138&view=rev
Author:   chambm
Date:     2012-11-21 22:54:56 +0000 (Wed, 21 Nov 2012)
Log Message:
-----------
- added fully qualified calls to escape_teamcity_string for tests that don't use "using namespace pwiz::util"

Modified Paths:
--------------
    trunk/pwiz/pwiz/utility/bindings/CLI/common/unit.hpp
    trunk/pwiz/pwiz/utility/misc/unit.hpp

Modified: trunk/pwiz/pwiz/utility/bindings/CLI/common/unit.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/bindings/CLI/common/unit.hpp	2012-11-21 22:21:32 UTC (rev 4137)
+++ trunk/pwiz/pwiz/utility/bindings/CLI/common/unit.hpp	2012-11-21 22:54:56 UTC (rev 4138)
@@ -155,7 +155,7 @@
 
 #define TEST_PROLOG_EX(argc, argv, suffix) \
     bfs::path testName = bfs::change_extension(bfs::basename(argv[0]), (suffix)); \
-    string teamcityTestName = escape_teamcity_string(testName.string()); \
+    string teamcityTestName = pwiz::util::escape_teamcity_string(testName.string()); \
     bpt::ptime testStartTime; \
     vector<string> testArgs(argv, argv+argc); \
     bool teamcityTestDecoration = find(testArgs.begin(), testArgs.end(), "--teamcity-test-decoration") != testArgs.end(); \
@@ -170,7 +170,7 @@
 
 #define TEST_FAILED(x) \
     if (teamcityTestDecoration) \
-        cout << "##teamcity[testFailed name='" << teamcityTestName << "' message='" << escape_teamcity_string((x)) << "']\n"; \
+        cout << "##teamcity[testFailed name='" << teamcityTestName << "' message='" << pwiz::util::escape_teamcity_string((x)) << "']\n"; \
     cerr << (x) << endl; \
     testExitStatus = 1;
 

Modified: trunk/pwiz/pwiz/utility/misc/unit.hpp
===================================================================
--- trunk/pwiz/pwiz/utility/misc/unit.hpp	2012-11-21 22:21:32 UTC (rev 4137)
+++ trunk/pwiz/pwiz/utility/misc/unit.hpp	2012-11-21 22:54:56 UTC (rev 4138)
@@ -144,7 +144,7 @@
 
 #define TEST_PROLOG_EX(argc, argv, suffix) \
     bfs::path testName = bfs::change_extension(bfs::basename(argv[0]), (suffix)); \
-    string teamcityTestName = escape_teamcity_string(testName.string()); \
+    string teamcityTestName = pwiz::util::escape_teamcity_string(testName.string()); \
     bpt::ptime testStartTime; \
     vector<string> testArgs(argv, argv+argc); \
     bool teamcityTestDecoration = find(testArgs.begin(), testArgs.end(), "--teamcity-test-decoration") != testArgs.end(); \
@@ -159,7 +159,7 @@
 
 #define TEST_FAILED(x) \
     if (teamcityTestDecoration) \
-        cout << "##teamcity[testFailed name='" << teamcityTestName << "' message='" << escape_teamcity_string((x)) << "']\n"; \
+        cout << "##teamcity[testFailed name='" << teamcityTestName << "' message='" << pwiz::util::escape_teamcity_string((x)) << "']\n"; \
     cerr << (x) << endl; \
     testExitStatus = 1;
 

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.