werk van vandaaag

git-svn-id: svn+ssh://gitlab/srv/svn-repos/pdb-redo/trunk@304 a1961a4f-ab94-4bcc-80e8-33b5a54de466

include/cif++/Cif++.h

@@ -389,10 +389,10 @@ namespace detail
 			return mRow[mColumns[ix]];
 		}
 		
-		getRowResult(Row& r, C... columns)
+		getRowResult(const Row& r, C... columns)
 			: mRow(r), mColumns({{columns...}}) {}
 	
-		Row& mRow;
+		const Row& mRow;
 		std::array<const char*, N> mColumns;
 	};
 	
@@ -519,7 +519,7 @@ class Row
 	}
 
 	template<typename... C>
-	auto get(C... columns) -> detail::getRowResult<C...>
+	auto get(C... columns) const -> detail::getRowResult<C...>
 	{
 		return detail::getRowResult<C...>(*this, columns...);
 	}

include/cif++/Compound.h

@@ -21,8 +21,6 @@ namespace mmcif
 // Entities themselves are made up of compounds. And compounds
 // contain CompoundAtom records for each atom.
 
-class Composition;
-class Entity;
 class Compound;
 class Link;
 struct CompoundAtom;

include/cif++/Structure.h

@@ -96,7 +96,6 @@ class Atom
 	void location(Point p);
 
 	const Compound& comp() const;
-	const Entity& ent() const;
 	bool isWater() const;
 	int charge() const;
 
@@ -141,6 +140,13 @@ class Atom
 
 	// the energy-type field
 	std::string energyType() const;
+	
+	// convenience routine
+	bool isBackBone() const
+	{
+		return labelAtomId() == "N" or labelAtomId() == "O" or
+			labelAtomId() == "C" or labelAtomId() == "CA";
+	}
 
   private:
  	struct AtomImpl*			mImpl;
@@ -210,8 +216,8 @@ class Monomer : public Residue
 	Monomer(const Monomer& rhs);
 	Monomer& operator=(const Monomer& rhs);
 
-	Monomer(Polymer& polymer, uint32 index);
-	Monomer(Polymer& polymer, uint32 index, int seqID,
+	Monomer(const Polymer& polymer, uint32 index);
+	Monomer(const Polymer& polymer, uint32 index, int seqID,
 		const std::string& compoundID, const std::string& altID);
 
 	// Assuming this is really an amino acid...
@@ -236,8 +242,8 @@ class Monomer : public Residue
 	static bool isCis(const Monomer& a, const Monomer& b);
 	
   private:
-	Polymer*	mPolymer;
-	uint32		mIndex;
+	const Polymer*	mPolymer;
+	uint32			mIndex;
 };
 
 // --------------------------------------------------------------------
@@ -245,6 +251,7 @@ class Monomer : public Residue
 class Polymer
 {
   public:
+	Polymer(const Structure& s, const std::string& asymID);
 	Polymer(const Structure& s, const std::string& entityID, const std::string& asymID);
 	Polymer(const Polymer&);
 	Polymer& operator=(const Polymer&);
@@ -255,7 +262,7 @@ class Polymer
 		typedef base_type::reference									reference;
 		typedef base_type::pointer										pointer;
 		
-		iterator(Polymer& p, uint32 index);
+		iterator(const Polymer& p, uint32 index);
 		iterator(iterator&& rhs);
 
 		iterator(const iterator& rhs);
@@ -285,21 +292,25 @@ class Polymer
 		bool		operator!=(const iterator& rhs) const				{ return mPolymer != rhs.mPolymer or mIndex != rhs.mIndex; }
 
 	  private:
-		Polymer*	mPolymer;
-		uint32		mIndex;
-		Monomer		mCurrent;
+		const Polymer*	mPolymer;
+		uint32			mIndex;
+		Monomer			mCurrent;
 	};
 
-	iterator begin();
-	iterator end();
+	iterator begin() const;
+	iterator end() const;
 	
 	size_t size() const							{ return mPolySeq.size(); }
 	Monomer operator[](size_t index) const;
+	
+	Monomer getBySeqID(int seqID) const;
 
 	Structure* structure() const	{ return mStructure; }
 	
 	std::string asymID() const		{ return mAsymID; }
 	std::string entityID() const	{ return mEntityID; }
+	
+	int Distance(const Monomer& a, const Monomer& b) const;
 
   private:
 
@@ -332,8 +343,6 @@ class File : public std::enable_shared_from_this<File>
 
 	struct FileImpl& impl() const						{ return *mImpl; }
 
-	std::vector<const Entity*> entities();
-
 	cif::Datablock& data();
 	cif::File& file();
 

src/Structure.cpp

@@ -708,7 +708,7 @@ Monomer& Monomer::operator=(const Monomer& rhs)
 	return *this;
 }
 
-Monomer::Monomer(Polymer& polymer, uint32 index)
+Monomer::Monomer(const Polymer& polymer, uint32 index)
 	: Residue(*polymer.structure())
 	, mPolymer(&polymer)
 	, mIndex(index)
@@ -716,7 +716,7 @@ Monomer::Monomer(Polymer& polymer, uint32 index)
 	
 }
 
-Monomer::Monomer(Polymer& polymer, uint32 index, int seqID, const string& compoundID, const string& altID)
+Monomer::Monomer(const Polymer& polymer, uint32 index, int seqID, const string& compoundID, const string& altID)
 	: Residue(*polymer.structure(), compoundID, polymer.asymID(), seqID, altID)
 	, mPolymer(&polymer)
 	, mIndex(index)
@@ -841,7 +841,7 @@ bool Monomer::isCis(const mmcif::Monomer& a, const mmcif::Monomer& b)
 // --------------------------------------------------------------------
 // polymer
 
-Polymer::iterator::iterator(Polymer& p, uint32 index)
+Polymer::iterator::iterator(const Polymer& p, uint32 index)
 	: mPolymer(&p), mIndex(index), mCurrent(p, index)
 {
 	auto& polySeq = mPolymer->mPolySeq;
@@ -916,22 +916,73 @@ Polymer::Polymer(const Polymer& rhs)
 	
 }
 
+Polymer::Polymer(const Structure& s, const string& asymID)
+	: mStructure(const_cast<Structure*>(&s)), mAsymID(asymID)
+	, mPolySeq(s.category("pdbx_poly_seq_scheme").find(cif::Key("asym_id") == mAsymID))
+{
+	mEntityID = mPolySeq.front()["entity_id"].as<string>();
+
+#if DEBUG
+	for (auto r: mPolySeq)
+		assert(r["entity_id"] == mEntityID);
+#endif
+	
+}
+
 Polymer::Polymer(const Structure& s, const string& entityID, const string& asymID)
 	: mStructure(const_cast<Structure*>(&s)), mEntityID(entityID), mAsymID(asymID)
 	, mPolySeq(s.category("pdbx_poly_seq_scheme").find(cif::Key("asym_id") == mAsymID and cif::Key("entity_id") == mEntityID))
 {
 }
 
-Polymer::iterator Polymer::begin()
+Polymer::iterator Polymer::begin() const
 {
 	return iterator(*this, 0);
 }
 
-Polymer::iterator Polymer::end()
+Polymer::iterator Polymer::end() const
 {
 	return iterator(*this, mPolySeq.size());
 }
 
+Monomer Polymer::getBySeqID(int seqID) const
+{
+	for (auto m: *this)
+		if (m.seqID() == seqID)
+			return m;
+
+	if (VERBOSE)
+		cerr << "Monomer with seqID " << seqID << " not found in polymer " << mAsymID << endl;
+
+	return Monomer();
+}
+
+int Polymer::Distance(const Monomer& a, const Monomer& b) const
+{
+	int result = numeric_limits<int>::max();
+	
+	if (a.asymID() == b.asymID())
+	{
+		int ixa = numeric_limits<int>::max(), ixb = numeric_limits<int>::max();
+	
+		int ix = 0, f = 0;
+		for (auto m: *this)
+		{
+			if (m.seqID() == a.seqID())
+				ixa = ix, ++f;
+			if (m.seqID() == b.seqID())
+				ixb = ix, ++f;
+			if (f == 2)
+			{
+				result = abs(ixa - ixb);
+				break;
+			}
+		}
+	}
+
+	return result;
+}
+
 //cif::RowSet Polymer::polySeqRows() const
 //{
 //	auto& cat = mStructure->category("pdbx_poly_seq_scheme");