This file is indexed.

/usr/include/rdkit/GraphMol/MolPickler.h is in librdkit-dev 201309-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  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
//
//  Copyright (C) 2001-2008 Greg Landrum and Rational Discovery LLC
//
//   @@ All Rights Reserved @@
//  This file is part of the RDKit.
//  The contents are covered by the terms of the BSD license
//  which is included in the file license.txt, found at the root
//  of the RDKit source tree.
//
#ifndef _RD_MOLPICKLE_H
#define _RD_MOLPICKLE_H

#include <Geometry/point.h>
#include <GraphMol/Atom.h>
#include <GraphMol/QueryAtom.h>
#include <GraphMol/Bond.h>
#include <GraphMol/QueryBond.h>

// Std stuff
#include <iostream>
#include <string>
#include <sstream>
#include <exception>
#ifdef WIN32
#include <ios>
#endif
#include <boost/cstdint.hpp>

namespace RDKit{
  class ROMol;
  class RingInfo;

  //! used to indicate exceptions whilst pickling (serializing) molecules
  class MolPicklerException : public std::exception {
    public :
      MolPicklerException(const char *msg) : _msg(msg) {};
      MolPicklerException(const std::string msg) : _msg(msg) {};
      const char *message () const { return _msg.c_str(); };
      ~MolPicklerException () throw () {};
    
    private :
      std::string _msg;
  };

  //! handles pickling (serializing) molecules
  class MolPickler{
  public:
    static const boost::int32_t versionMajor,versionMinor,versionPatch; //!< mark the pickle version
    static const boost::int32_t endianId;  //! mark the endian-ness of the pickle

    //! the pickle format is tagged using these tags:
    //! NOTE: if you add to this list, be sure to put new entries AT THE BOTTOM, otherwise
    //! you will break old pickles.
    typedef enum {
      VERSION=0,
      BEGINATOM,
      ATOM_INDEX,
      ATOM_NUMBER,
      ATOM_POS,
      ATOM_CHARGE,
      ATOM_NEXPLICIT,
      ATOM_CHIRALTAG,
      ATOM_MASS,
      ATOM_ISAROMATIC,
      ENDATOM,
      BEGINBOND,
      BOND_INDEX,
      BOND_BEGATOMIDX,
      BOND_ENDATOMIDX,
      BOND_TYPE,
      BOND_DIR,
      ENDBOND,
      BEGINPROPS,
      ENDPROPS,
      BEGINSSSR,
      ENDSSSR,
      ENDMOL,
      BEGINCONFS,
      ATOM_MAPNUMBER,
      BEGINQUERY,
      QUERY_VALUE,
      QUERY_ISNEGATED,
      QUERY_NUMCHILDREN,
      QUERY_BOOL,
      QUERY_AND,
      QUERY_OR,
      QUERY_XOR,
      QUERY_EQUALS,
      QUERY_GREATER,
      QUERY_GREATEREQUAL,
      QUERY_LESS,
      QUERY_LESSEQUAL,
      QUERY_RANGE,
      QUERY_SET,
      QUERY_NULL,
      QUERY_ATOMRING,
      QUERY_RECURSIVE,
      ENDQUERY,
      ATOM_DUMMYLABEL,
      BEGIN_ATOM_MONOMER,
      ATOM_PDB_RESIDUE_SERIALNUMBER,
      ATOM_PDB_RESIDUE_ALTLOC,
      ATOM_PDB_RESIDUE_RESIDUENAME,
      ATOM_PDB_RESIDUE_CHAINID,
      ATOM_PDB_RESIDUE_INSERTIONCODE,
      ATOM_PDB_RESIDUE_OCCUPANCY,
      ATOM_PDB_RESIDUE_TEMPFACTOR,
      ATOM_PDB_RESIDUE_ISHETEROATOM,
      ATOM_PDB_RESIDUE_SECONDARYSTRUCTURE,
      ATOM_PDB_RESIDUE_RESIDUENUMBER,
      ATOM_PDB_RESIDUE_SEGMENTNUMBER,
      END_ATOM_MONOMER,
    } Tags;

    //! pickles a molecule and sends the results to stream \c ss
    static void pickleMol(const ROMol *mol,std::ostream &ss);
    static void pickleMol(const ROMol &mol,std::ostream &ss) {MolPickler::pickleMol(&mol,ss);};
    //! pickles a molecule and adds the results to string \c res
    static void pickleMol(const ROMol *mol,std::string &res);
    static void pickleMol(const ROMol &mol,std::string &res) {MolPickler::pickleMol(&mol,res);};

    //! constructs a molecule from a pickle stored in a string
    static void molFromPickle(const std::string &pickle,ROMol *mol);
    static void molFromPickle(const std::string &pickle,ROMol &mol) {MolPickler::molFromPickle(pickle,&mol);};

    //! constructs a molecule from a pickle stored in a stream
    static void molFromPickle(std::istream &ss,ROMol *mol);
    static void molFromPickle(std::istream &ss,ROMol &mol) { MolPickler::molFromPickle(ss,&mol); };
  private:
    //! do the actual work of pickling a molecule
    template <typename T>
    static void _pickle(const ROMol *mol,std::ostream &ss);

    //! do the actual work of pickling an Atom
    template <typename T>
    static void _pickleAtom(std::ostream &ss,const Atom *atom);

    //! do the actual work of pickling a Bond
    template <typename T>
    static void _pickleBond(std::ostream &ss,const Bond *bond,
			    std::map<int,int> &atomIdxMap);

    //! do the actual work of pickling an SSSR structure
    template <typename T>
    static void _pickleSSSR(std::ostream &ss,const RingInfo *ringInfo,
			    std::map<int,int> &atomIdxMap);

    //! do the actual work of pickling a Conformer
    template <typename T>
    static void _pickleConformer(std::ostream &ss,const Conformer *conf);

    //! do the actual work of de-pickling a molecule
    template <typename T>
    static void _depickle(std::istream &ss,ROMol *mol, int version,int numAtoms);


    //! extract atomic data from a pickle and add the resulting Atom to the molecule
    template <typename T>
    static Atom *_addAtomFromPickle(std::istream &ss,ROMol *mol, RDGeom::Point3D &pos,
                                    int version,
                                    bool directMap=false);

    //! extract bond data from a pickle and add the resulting Bond to the molecule
    template <typename T>
    static Bond *_addBondFromPickle(std::istream &ss,ROMol *mol,
				    int version,
				    bool directMap=false);

    //! extract ring info from a pickle and add the resulting RingInfo to the molecule
    template <typename T>
    static void _addRingInfoFromPickle(std::istream &ss,ROMol *mol,
				       int version,
				       bool directMap=false);

    //! extract a conformation from a pickle
    template <typename T> 
      static Conformer *_conformerFromPickle(std::istream &ss,int version);

    //! backwards compatibility
    static void _pickleV1(const ROMol *mol,std::ostream &ss);
    //! backwards compatibility
    static void _depickleV1(std::istream &ss,ROMol *mol);
    //! backwards compatibility
    static void _addAtomFromPickleV1(std::istream &ss,ROMol *mol);
    //! backwards compatibility
    static void _addBondFromPickleV1(std::istream &ss,ROMol *mol);

  };  
  
};


#endif