RDKit
Open-source cheminformatics and machine learning.
Loading...
Searching...
No Matches
MolPickler.h
Go to the documentation of this file.
1///
2// Copyright (C) 2001-2021 Greg Landrum and Rational Discovery LLC
3//
4// @@ All Rights Reserved @@
5// This file is part of the RDKit.
6// The contents are covered by the terms of the BSD license
7// which is included in the file license.txt, found at the root
8// of the RDKit source tree.
9//
10#include <RDGeneral/export.h>
11#ifndef RD_MOLPICKLE_H
12#define RD_MOLPICKLE_H
13
14#include <Geometry/point.h>
15#include <GraphMol/Atom.h>
16#include <GraphMol/QueryAtom.h>
17#include <GraphMol/Bond.h>
18#include <GraphMol/QueryBond.h>
19#include <RDGeneral/StreamOps.h>
20#include <boost/utility/binary.hpp>
21#include <boost/variant.hpp>
22#include <Query/QueryObjects.h>
23
24// Std stuff
25#include <iostream>
26#include <string>
27#include <sstream>
28#include <exception>
29#ifdef WIN32
30#include <ios>
31#endif
32#include <cstdint>
34
35namespace RDKit {
36class ROMol;
37class RingInfo;
38
39//! used to indicate exceptions whilst pickling (serializing) molecules
40class RDKIT_GRAPHMOL_EXPORT MolPicklerException : public std::exception {
41 public:
42 MolPicklerException(const char *msg) : _msg(msg) {}
43 MolPicklerException(const std::string msg) : _msg(msg) {}
44 const char *what() const noexcept override { return _msg.c_str(); }
45 ~MolPicklerException() noexcept override = default;
46
47 private:
48 std::string _msg;
49};
50
51namespace PicklerOps {
53 PropertyPickleOptions, unsigned int,
54 NoProps = 0, // no data pickled (default pickling, single-precision coords)
55 MolProps = 0x1, // only public non computed properties
56 AtomProps = 0x2, BondProps = 0x4,
57 QueryAtomData =
58 0x2, // n.b. DEPRECATED and set to AtomProps (does the same work)
59 PrivateProps = 0x10, ComputedProps = 0x20,
60 AllProps = 0x0000FFFF, // all data pickled
61 CoordsAsDouble = 0x00010000, // save coordinates in double precision
62 NoConformers =
63 0x00020000 // do not include conformers or associated properties
64);
65} // namespace PicklerOps
66
67//! handles pickling (serializing) molecules
69 public:
70 static const std::int32_t versionMajor; //!< mark the pickle major version
71 static const std::int32_t versionMinor; //!< mark the pickle minor version
72 static const std::int32_t versionPatch; //!< mark the pickle patch version
73 static const std::int32_t endianId; //!< mark the endian-ness of the pickle
74
75 //! the pickle format is tagged using these tags:
76 //! NOTE: if you add to this list, be sure to put new entries AT THE BOTTOM,
77 /// otherwise
78 //! you will break old pickles.
79 typedef enum {
80 VERSION = 0,
151 // add new entries above here
152 INVALID_TAG = 255
153 } Tags;
154
155 static unsigned int getDefaultPickleProperties();
156 static void setDefaultPickleProperties(unsigned int);
157
159 static void addCustomPropHandler(const CustomPropHandler &handler);
160
161 //! pickles a molecule and sends the results to stream \c ss
162 static void pickleMol(const ROMol *mol, std::ostream &ss);
163 static void pickleMol(const ROMol *mol, std::ostream &ss,
164 unsigned int propertyFlags);
165
166 static void pickleMol(const ROMol &mol, std::ostream &ss);
167
168 static void pickleMol(const ROMol &mol, std::ostream &ss,
169 unsigned int propertyFlags) {
170 MolPickler::pickleMol(&mol, ss, propertyFlags);
171 }
172
173 //! pickles a molecule and adds the results to string \c res
174 static void pickleMol(const ROMol *mol, std::string &res);
175 static void pickleMol(const ROMol *mol, std::string &res,
176 unsigned int propertyFlags);
177 static void pickleMol(const ROMol &mol, std::string &res);
178 static void pickleMol(const ROMol &mol, std::string &res,
179 unsigned int propertyFlags) {
180 MolPickler::pickleMol(&mol, res, propertyFlags);
181 }
182
183 //! constructs a molecule from a pickle stored in a string
184 static void molFromPickle(const std::string &pickle, ROMol *mol,
185 unsigned int propertyFlags);
186 static void molFromPickle(const std::string &pickle, ROMol &mol,
187 unsigned int propertyFlags) {
188 MolPickler::molFromPickle(pickle, &mol, propertyFlags);
189 }
190 static void molFromPickle(const std::string &pickle, ROMol *mol) {
191 MolPickler::molFromPickle(pickle, mol,
192 PicklerOps::PropertyPickleOptions::AllProps);
193 }
194 static void molFromPickle(const std::string &pickle, ROMol &mol) {
195 MolPickler::molFromPickle(pickle, &mol,
196 PicklerOps::PropertyPickleOptions::AllProps);
197 }
198
199 //! constructs a molecule from a pickle stored in a stream
200 static void molFromPickle(std::istream &ss, ROMol *mol,
201 unsigned int propertyFlags);
202 static void molFromPickle(std::istream &ss, ROMol &mol,
203 unsigned int propertyFlags) {
204 MolPickler::molFromPickle(ss, &mol, propertyFlags);
205 }
206 static void molFromPickle(std::istream &ss, ROMol *mol) {
207 MolPickler::molFromPickle(ss, mol,
208 PicklerOps::PropertyPickleOptions::AllProps);
209 }
210 static void molFromPickle(std::istream &ss, ROMol &mol) {
211 MolPickler::molFromPickle(ss, &mol,
212 PicklerOps::PropertyPickleOptions::AllProps);
213 }
214
215 private:
216 //! Pickle nonquery atom data
217 static std::int32_t _pickleAtomData(std::ostream &tss, const Atom *atom);
218 //! depickle nonquery atom data
219 static void _unpickleAtomData(std::istream &tss, Atom *atom, int version);
220
221 static void _pickleQueryAtomData(std::ostream &tss, const Atom *atom);
222
223 //! do the actual work of pickling a molecule
224 template <typename T>
225 static void _pickle(const ROMol *mol, std::ostream &ss,
226 unsigned int propertyFlags);
227
228 //! do the actual work of pickling an Atom
229 template <typename T>
230 static void _pickleAtom(std::ostream &ss, const Atom *atom);
231
232 //! do the actual work of pickling a Bond
233 template <typename T>
234 static void _pickleBond(std::ostream &ss, const Bond *bond,
235 std::map<int, int> &atomIdxMap);
236
237 //! do the actual work of pickling an SSSR structure
238 template <typename T>
239 static void _pickleSSSR(std::ostream &ss, const RingInfo *ringInfo,
240 std::map<int, int> &atomIdxMap);
241
242 //! do the actual work of pickling a SubstanceGroup
243 template <typename T>
244 static void _pickleSubstanceGroup(std::ostream &ss,
245 const SubstanceGroup &sgroup,
246 std::map<int, int> &atomIdxMap,
247 std::map<int, int> &bondIdxMap);
248
249 //! do the actual work of pickling Stereo Group data
250 template <typename T>
251 static void _pickleStereo(std::ostream &ss, std::vector<StereoGroup> groups,
252 std::map<int, int> &atomIdxMap,
253 std::map<int, int> &bondIdxMap);
254
255 //! do the actual work of pickling a Conformer
256 template <typename T, typename C>
257 static void _pickleConformer(std::ostream &ss, const Conformer *conf);
258
259 //! do the actual work of de-pickling a molecule
260 template <typename T>
261 static void _depickle(std::istream &ss, ROMol *mol, int version, int numAtoms,
262 unsigned int propertyFlags);
263
264 //! extract atomic data from a pickle and add the resulting Atom to the
265 /// molecule
266 template <typename T>
267 static Atom *_addAtomFromPickle(std::istream &ss, ROMol *mol,
268 RDGeom::Point3D &pos, int version,
269 bool directMap = false);
270
271 //! extract bond data from a pickle and add the resulting Bond to the molecule
272 template <typename T>
273 static Bond *_addBondFromPickle(std::istream &ss, ROMol *mol, int version,
274 bool directMap = false);
275
276 //! extract ring info from a pickle and add the resulting RingInfo to the
277 /// molecule
278 template <typename T>
279 static void _addRingInfoFromPickle(
280 std::istream &ss, ROMol *mol, int version, bool directMap = false,
281 FIND_RING_TYPE ringType =
282 FIND_RING_TYPE::FIND_RING_TYPE_OTHER_OR_UNKNOWN);
283
284 //! extract a SubstanceGroup from a pickle
285 template <typename T>
286 static SubstanceGroup _getSubstanceGroupFromPickle(std::istream &ss,
287 ROMol *mol, int version);
288
289 template <typename T>
290 static void _depickleStereo(std::istream &ss, ROMol *mol, int version);
291
292 //! extract a conformation from a pickle
293 template <typename T, typename C>
294 static Conformer *_conformerFromPickle(std::istream &ss, int version);
295
296 //! pickle standard properties
297 static void _pickleProperties(std::ostream &ss, const RDProps &props,
298 unsigned int pickleFlags);
299 //! unpickle standard properties
300 static void _unpickleProperties(std::istream &ss, RDProps &props,
301 int version);
302
303 //! backwards compatibility
304 static void _pickleV1(const ROMol *mol, std::ostream &ss);
305 //! backwards compatibility
306 static void _depickleV1(std::istream &ss, ROMol *mol);
307 //! backwards compatibility
308 static void _addAtomFromPickleV1(std::istream &ss, ROMol *mol);
309 //! backwards compatibility
310 static void _addBondFromPickleV1(std::istream &ss, ROMol *mol);
311};
312
313namespace PicklerOps {
314// clang-format off
315using QueryDetails = boost::variant<
316 MolPickler::Tags, std::tuple<MolPickler::Tags, int32_t>,
317 std::tuple<MolPickler::Tags, int32_t, int32_t>,
318 std::tuple<MolPickler::Tags, int32_t, int32_t, int32_t, char>,
319 std::tuple<MolPickler::Tags, std::set<int32_t>>,
320 std::tuple<MolPickler::Tags, std::string>,
321 std::tuple<MolPickler::Tags, PairHolder, double>>;
322// clang-format on
323template <class T>
325
326} // namespace PicklerOps
327
328}; // namespace RDKit
329
330#endif
Defines the Atom class and associated typedefs.
#define BETTER_ENUM(Enum, Underlying,...)
Definition BetterEnums.h:17
Pulls in all the query types.
Base class for all queries.
Definition Query.h:45
The class for representing atoms.
Definition Atom.h:75
class for representing a bond
Definition Bond.h:47
The class for representing 2D or 3D conformation of a molecule.
Definition Conformer.h:46
used to indicate exceptions whilst pickling (serializing) molecules
Definition MolPickler.h:40
~MolPicklerException() noexcept override=default
const char * what() const noexcept override
Definition MolPickler.h:44
MolPicklerException(const std::string msg)
Definition MolPickler.h:43
MolPicklerException(const char *msg)
Definition MolPickler.h:42
handles pickling (serializing) molecules
Definition MolPickler.h:68
static const std::int32_t endianId
mark the endian-ness of the pickle
Definition MolPickler.h:73
static void molFromPickle(std::istream &ss, ROMol *mol)
Definition MolPickler.h:206
static void molFromPickle(const std::string &pickle, ROMol &mol, unsigned int propertyFlags)
Definition MolPickler.h:186
static void molFromPickle(std::istream &ss, ROMol &mol, unsigned int propertyFlags)
Definition MolPickler.h:202
static void pickleMol(const ROMol *mol, std::string &res, unsigned int propertyFlags)
static void molFromPickle(std::istream &ss, ROMol *mol, unsigned int propertyFlags)
constructs a molecule from a pickle stored in a stream
static void molFromPickle(const std::string &pickle, ROMol *mol)
Definition MolPickler.h:190
@ ATOM_PDB_RESIDUE_SECONDARYSTRUCTURE
Definition MolPickler.h:134
static void pickleMol(const ROMol &mol, std::ostream &ss)
static void pickleMol(const ROMol &mol, std::string &res, unsigned int propertyFlags)
Definition MolPickler.h:178
static void pickleMol(const ROMol *mol, std::ostream &ss, unsigned int propertyFlags)
static void molFromPickle(const std::string &pickle, ROMol *mol, unsigned int propertyFlags)
constructs a molecule from a pickle stored in a string
static const CustomPropHandlerVec & getCustomPropHandlers()
static void molFromPickle(const std::string &pickle, ROMol &mol)
Definition MolPickler.h:194
static void setDefaultPickleProperties(unsigned int)
static const std::int32_t versionMajor
mark the pickle major version
Definition MolPickler.h:70
static const std::int32_t versionMinor
mark the pickle minor version
Definition MolPickler.h:71
static void molFromPickle(std::istream &ss, ROMol &mol)
Definition MolPickler.h:210
static void pickleMol(const ROMol &mol, std::ostream &ss, unsigned int propertyFlags)
Definition MolPickler.h:168
static void pickleMol(const ROMol *mol, std::ostream &ss)
pickles a molecule and sends the results to stream ss
static void pickleMol(const ROMol *mol, std::string &res)
pickles a molecule and adds the results to string res
static unsigned int getDefaultPickleProperties()
static void addCustomPropHandler(const CustomPropHandler &handler)
static const std::int32_t versionPatch
mark the pickle patch version
Definition MolPickler.h:72
static void pickleMol(const ROMol &mol, std::string &res)
The class for representing SubstanceGroups.
#define RDKIT_GRAPHMOL_EXPORT
Definition export.h:233
QueryDetails getQueryDetails(const Queries::Query< int, T const *, true > *query)
boost::variant< MolPickler::Tags, std::tuple< MolPickler::Tags, int32_t >, std::tuple< MolPickler::Tags, int32_t, int32_t >, std::tuple< MolPickler::Tags, int32_t, int32_t, int32_t, char >, std::tuple< MolPickler::Tags, std::set< int32_t > >, std::tuple< MolPickler::Tags, std::string >, std::tuple< MolPickler::Tags, PairHolder, double > > QueryDetails
Definition MolPickler.h:321
Std stuff.
FIND_RING_TYPE
A class to store information about a molecule's rings.
Definition RingInfo.h:31
std::vector< std::shared_ptr< const CustomPropHandler > > CustomPropHandlerVec
Definition StreamOps.h:388