1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
//
// Copyright (c) 2007-2014, Novartis Institutes for BioMedical Research Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following
// disclaimer in the documentation and/or other materials provided
// with the distribution.
// * Neither the name of Novartis Institutes for BioMedical Research Inc.
// nor the names of its contributors may be used to endorse or promote
// products derived from this software without specific prior written
// permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
#include <RDGeneral/export.h>
#ifndef RD_REACTIONPARSER_H_21Aug2006
#define RD_REACTIONPARSER_H_21Aug2006
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <boost/format.hpp>
#include <RDGeneral/BadFileException.h>
#include <RDGeneral/FileParseException.h>
namespace RDKit {
class ChemicalReaction;
//! used to indicate an error in parsing reaction data
class RDKIT_CHEMREACTIONS_EXPORT ChemicalReactionParserException
: public std::exception {
public:
//! construct with an error message
explicit ChemicalReactionParserException(const char *msg) : _msg(msg){};
//! construct with an error message
explicit ChemicalReactionParserException(const std::string &msg)
: _msg(msg){};
//! get the error message
const char *what() const noexcept override { return _msg.c_str(); };
~ChemicalReactionParserException() noexcept {};
private:
std::string _msg;
};
//---------------------------------------------------------------------------
//! \name Reaction SMARTS/SMILES Support
//@{
//! Parse a string containing "Reaction SMARTS" into a ChemicalReaction
/*!
Our definition of Reaction SMARTS is something that looks a lot like
reaction SMILES, except that SMARTS queries are allowed on the reactant
side and that atom-map numbers are required (at least for now)
\param text the SMARTS to convert
\param replacements a string->string map of replacement strings.
\see SmilesToMol for more information about replacements
\param useSmiles if set, the SMILES parser will be used instead of the
SMARTS
parserfor the individual components
*/
RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction *RxnSmartsToChemicalReaction(
const std::string &text,
std::map<std::string, std::string> *replacements = nullptr,
bool useSmiles = false);
//! returns the reaction SMARTS for a reaction
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToRxnSmarts(
const ChemicalReaction &rxn);
//! returns the reaction SMILES for a reaction
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToRxnSmiles(
const ChemicalReaction &rxn, bool canonical = true);
//@}
//---------------------------------------------------------------------------
//! \name Reaction Mol Support
//@{
//! Parse a ROMol into a ChemicalReaction, RXN role must be set before
/*!
Alternative to build a reaction from a molecule (fragments) which have RXN
roles
set as atom properties: common_properties::molRxnRole (1=reactant, 2=product,
3=agent)
\param mol ROMol with RXN roles set
*/
RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction *RxnMolToChemicalReaction(
const ROMol &mol);
//! returns a ROMol with RXN roles used to describe the reaction
RDKIT_CHEMREACTIONS_EXPORT ROMol *ChemicalReactionToRxnMol(
const ChemicalReaction &rxn);
//@}
//---------------------------------------------------------------------------
//! \name MDL rxn Support
//@{
//! Parse a text block in MDL rxn format into a ChemicalReaction
RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction *RxnBlockToChemicalReaction(
const std::string &rxnBlock, bool sanitize = false, bool removeHs = false,
bool strictParsing = true);
//! Parse a file in MDL rxn format into a ChemicalReaction
RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction *RxnFileToChemicalReaction(
const std::string &fileName, bool sanitize = false, bool removeHs = false,
bool strictParsing = true);
//! Parse a text stream in MDL rxn format into a ChemicalReaction
RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction *RxnDataStreamToChemicalReaction(
std::istream &rxnStream, unsigned int &line, bool sanitize = false,
bool removeHs = false, bool strictParsing = true);
//! returns an rxn block for a reaction
/*!
\param rxn chemical reaction
\param separateAgents flag to decide if agents were put in a separate block,
otherwise they were included in the reactants block
(default)
*/
RDKIT_CHEMREACTIONS_EXPORT std::string ChemicalReactionToRxnBlock(
const ChemicalReaction &rxn, bool separateAgents = false);
//@}
//---------------------------------------------------------------------------
//! \name PNG Support
//@{
//! Tags used for PNG metadata
namespace PNGData {
RDKIT_CHEMREACTIONS_EXPORT extern const std::string rxnSmilesTag;
RDKIT_CHEMREACTIONS_EXPORT extern const std::string rxnSmartsTag;
RDKIT_CHEMREACTIONS_EXPORT extern const std::string rxnRxnTag;
RDKIT_CHEMREACTIONS_EXPORT extern const std::string rxnPklTag;
} // namespace PNGData
//! \brief constructs a ChemicalReaction from the metadata in a PNG stream
/*!
Looks through the metadata in the PNG to find the first tag that matches one of
the tags in \c RDKit::PNGData. A molecule is constructed from this chunk.
Throws a \c FileParseException if no suitable tag is found.
The caller is responsible for the returned pointer.
*/
RDKIT_CHEMREACTIONS_EXPORT ChemicalReaction *PNGStreamToChemicalReaction(
std::istream &pngStream);
//! \brief constructs a ChemicalReaction from the metadata in a PNG string
//! See \c PNGStreamToChemicalReaction() for more details
inline ChemicalReaction *PNGStringToChemicalReaction(const std::string &data) {
std::stringstream inStream(data);
return PNGStreamToChemicalReaction(inStream);
};
//! \brief constructs a ChemicalReaction from the metadata in a PNG file
//! See \c PNGStreamToChemicalReaction() for more details
inline ChemicalReaction *PNGFileToChemicalReaction(const std::string &fname) {
std::ifstream inStream(fname.c_str(), std::ios::binary);
if (!inStream || (inStream.bad())) {
throw BadFileException((boost::format("Bad input file %s") % fname).str());
}
return PNGStreamToChemicalReaction(inStream);
};
//! \brief adds metadata for a ChemicalReaction to the data from a PNG stream.
//! The modified PNG data is returned.
/*!
\param rxn the reaction to add
\param iStream the stream to read from
\param includePkl include a reaction pickle
\param includeSmiles include reaction SMILES for the reaction
\param includeSmarts include reaction SMARTS for the reaction
\param includeRxn include an RXN block for the reaction
*/
RDKIT_CHEMREACTIONS_EXPORT std::string addChemicalReactionToPNGStream(
const ChemicalReaction &rxn, std::istream &iStream, bool includePkl = true,
bool includeSmiles = true, bool includeSmarts = false,
bool includeRxn = false);
//! \brief adds metadata for a ChemicalReaction to the data from a PNG string.
//! See addChemicalReactionToPNGStream() for more details.
inline std::string addChemicalReactionToPNGString(const ChemicalReaction &rxn,
const std::string &pngString,
bool includePkl = true,
bool includeSmiles = true,
bool includeSmarts = false,
bool includeRxn = false) {
std::stringstream inStream(pngString);
return addChemicalReactionToPNGStream(
rxn, inStream, includePkl, includeSmiles, includeSmarts, includeRxn);
}
//! \brief adds metadata for a ChemicalReaction to the data from a PNG string.
//! See addChemicalReactionToPNGStream() for more details.
inline std::string addChemicalReactionToPNGFile(const ChemicalReaction &rxn,
const std::string &fname,
bool includePkl = true,
bool includeSmiles = true,
bool includeSmarts = false,
bool includeRxn = false) {
std::ifstream inStream(fname.c_str(), std::ios::binary);
return addChemicalReactionToPNGStream(
rxn, inStream, includePkl, includeSmiles, includeSmarts, includeRxn);
}
//@}
}; // namespace RDKit
#endif
|
