The swig generated wrapper for OpenBabel::OBMol

OBMol.cs

/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 1.3.35
 *
 * Do not make changes to this file unless you know what you are doing--modify
 * the SWIG interface file instead.
 * ----------------------------------------------------------------------------- */

namespace OpenBabel {

using System;
using System.Runtime.InteropServices;

public partial class OBMol : OBBase {
  private HandleRef swigCPtr;

  internal OBMol(IntPtr cPtr, bool cMemoryOwn) : base(openbabelPINVOKE.OBMolUpcast(cPtr), cMemoryOwn) {
    swigCPtr = new HandleRef(this, cPtr);
  }

  internal static HandleRef getCPtr(OBMol obj) {
    return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
  }

  ~OBMol() {
    Dispose();
  }

  public override void Dispose() {
    lock(this) {
      if(swigCPtr.Handle != IntPtr.Zero && swigCMemOwn) {
        swigCMemOwn = false;
        openbabelPINVOKE.delete_OBMol(swigCPtr);
      }
      swigCPtr = new HandleRef(null, IntPtr.Zero);
      GC.SuppressFinalize(this);
      base.Dispose();
    }
  }

  public OBMol() : this(openbabelPINVOKE.new_OBMol__SWIG_0(), true) {
  }

  public OBMol(OBMol arg0) : this(openbabelPINVOKE.new_OBMol__SWIG_1(OBMol.getCPtr(arg0)), true) {
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void ReserveAtoms(int natoms) {
    openbabelPINVOKE.OBMol_ReserveAtoms(swigCPtr, natoms);
  }

  public virtual OBAtom CreateAtom() {
    IntPtr cPtr = openbabelPINVOKE.OBMol_CreateAtom(swigCPtr);
    OBAtom ret = (cPtr == IntPtr.Zero) ? null : new OBAtom(cPtr, false);
    return ret;
  }

  public virtual OBBond CreateBond() {
    IntPtr cPtr = openbabelPINVOKE.OBMol_CreateBond(swigCPtr);
    OBBond ret = (cPtr == IntPtr.Zero) ? null : new OBBond(cPtr, false);
    return ret;
  }

  public virtual OBResidue CreateResidue() {
    IntPtr cPtr = openbabelPINVOKE.OBMol_CreateResidue(swigCPtr);
    OBResidue ret = (cPtr == IntPtr.Zero) ? null : new OBResidue(cPtr, false);
    return ret;
  }

  public virtual void DestroyAtom(OBAtom arg0) {
    openbabelPINVOKE.OBMol_DestroyAtom(swigCPtr, OBAtom.getCPtr(arg0));
  }

  public virtual void DestroyBond(OBBond arg0) {
    openbabelPINVOKE.OBMol_DestroyBond(swigCPtr, OBBond.getCPtr(arg0));
  }

  public virtual void DestroyResidue(OBResidue arg0) {
    openbabelPINVOKE.OBMol_DestroyResidue(swigCPtr, OBResidue.getCPtr(arg0));
  }

  public bool AddAtom(OBAtom arg0) {
    bool ret = openbabelPINVOKE.OBMol_AddAtom(swigCPtr, OBAtom.getCPtr(arg0));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool InsertAtom(OBAtom arg0) {
    bool ret = openbabelPINVOKE.OBMol_InsertAtom(swigCPtr, OBAtom.getCPtr(arg0));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool AddBond(int beginIdx, int endIdx, int order, int flags, int insertpos) {
    bool ret = openbabelPINVOKE.OBMol_AddBond__SWIG_0(swigCPtr, beginIdx, endIdx, order, flags, insertpos);
    return ret;
  }

  public bool AddBond(int beginIdx, int endIdx, int order, int flags) {
    bool ret = openbabelPINVOKE.OBMol_AddBond__SWIG_1(swigCPtr, beginIdx, endIdx, order, flags);
    return ret;
  }

  public bool AddBond(int beginIdx, int endIdx, int order) {
    bool ret = openbabelPINVOKE.OBMol_AddBond__SWIG_2(swigCPtr, beginIdx, endIdx, order);
    return ret;
  }

  public bool AddBond(OBBond arg0) {
    bool ret = openbabelPINVOKE.OBMol_AddBond__SWIG_3(swigCPtr, OBBond.getCPtr(arg0));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool AddResidue(OBResidue arg0) {
    bool ret = openbabelPINVOKE.OBMol_AddResidue(swigCPtr, OBResidue.getCPtr(arg0));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public OBAtom NewAtom() {
    IntPtr cPtr = openbabelPINVOKE.OBMol_NewAtom(swigCPtr);
    OBAtom ret = (cPtr == IntPtr.Zero) ? null : new OBAtom(cPtr, false);
    return ret;
  }

  public OBBond NewBond() {
    IntPtr cPtr = openbabelPINVOKE.OBMol_NewBond(swigCPtr);
    OBBond ret = (cPtr == IntPtr.Zero) ? null : new OBBond(cPtr, false);
    return ret;
  }

  public OBResidue NewResidue() {
    IntPtr cPtr = openbabelPINVOKE.OBMol_NewResidue(swigCPtr);
    OBResidue ret = (cPtr == IntPtr.Zero) ? null : new OBResidue(cPtr, false);
    return ret;
  }

  public bool DeleteAtom(OBAtom arg0, bool destroyAtom) {
    bool ret = openbabelPINVOKE.OBMol_DeleteAtom__SWIG_0(swigCPtr, OBAtom.getCPtr(arg0), destroyAtom);
    return ret;
  }

  public bool DeleteAtom(OBAtom arg0) {
    bool ret = openbabelPINVOKE.OBMol_DeleteAtom__SWIG_1(swigCPtr, OBAtom.getCPtr(arg0));
    return ret;
  }

  public bool DeleteBond(OBBond arg0, bool destroyBond) {
    bool ret = openbabelPINVOKE.OBMol_DeleteBond__SWIG_0(swigCPtr, OBBond.getCPtr(arg0), destroyBond);
    return ret;
  }

  public bool DeleteBond(OBBond arg0) {
    bool ret = openbabelPINVOKE.OBMol_DeleteBond__SWIG_1(swigCPtr, OBBond.getCPtr(arg0));
    return ret;
  }

  public bool DeleteResidue(OBResidue arg0, bool destroyResidue) {
    bool ret = openbabelPINVOKE.OBMol_DeleteResidue__SWIG_0(swigCPtr, OBResidue.getCPtr(arg0), destroyResidue);
    return ret;
  }

  public bool DeleteResidue(OBResidue arg0) {
    bool ret = openbabelPINVOKE.OBMol_DeleteResidue__SWIG_1(swigCPtr, OBResidue.getCPtr(arg0));
    return ret;
  }

  public virtual void BeginModify() {
    openbabelPINVOKE.OBMol_BeginModify(swigCPtr);
  }

  public virtual void EndModify(bool nukePerceivedData) {
    openbabelPINVOKE.OBMol_EndModify__SWIG_0(swigCPtr, nukePerceivedData);
  }

  public virtual void EndModify() {
    openbabelPINVOKE.OBMol_EndModify__SWIG_1(swigCPtr);
  }

  public int GetMod() {
    int ret = openbabelPINVOKE.OBMol_GetMod(swigCPtr);
    return ret;
  }

  public void IncrementMod() {
    openbabelPINVOKE.OBMol_IncrementMod(swigCPtr);
  }

  public void DecrementMod() {
    openbabelPINVOKE.OBMol_DecrementMod(swigCPtr);
  }

  public int GetFlags() {
    int ret = openbabelPINVOKE.OBMol_GetFlags(swigCPtr);
    return ret;
  }

  public string GetTitle(bool replaceNewlines) {
    string ret = openbabelPINVOKE.OBMol_GetTitle__SWIG_0(swigCPtr, replaceNewlines);
    return ret;
  }

  public string GetTitle() {
    string ret = openbabelPINVOKE.OBMol_GetTitle__SWIG_1(swigCPtr);
    return ret;
  }

  public uint NumAtoms() {
    uint ret = openbabelPINVOKE.OBMol_NumAtoms(swigCPtr);
    return ret;
  }

  public uint NumBonds() {
    uint ret = openbabelPINVOKE.OBMol_NumBonds(swigCPtr);
    return ret;
  }

  public uint NumHvyAtoms() {
    uint ret = openbabelPINVOKE.OBMol_NumHvyAtoms(swigCPtr);
    return ret;
  }

  public uint NumResidues() {
    uint ret = openbabelPINVOKE.OBMol_NumResidues(swigCPtr);
    return ret;
  }

  public uint NumRotors() {
    uint ret = openbabelPINVOKE.OBMol_NumRotors(swigCPtr);
    return ret;
  }

  public OBAtom GetAtom(int idx) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_GetAtom(swigCPtr, idx);
    OBAtom ret = (cPtr == IntPtr.Zero) ? null : new OBAtom(cPtr, false);
    return ret;
  }

  public OBAtom GetFirstAtom() {
    IntPtr cPtr = openbabelPINVOKE.OBMol_GetFirstAtom(swigCPtr);
    OBAtom ret = (cPtr == IntPtr.Zero) ? null : new OBAtom(cPtr, false);
    return ret;
  }

  public OBBond GetBond(int idx) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_GetBond__SWIG_0(swigCPtr, idx);
    OBBond ret = (cPtr == IntPtr.Zero) ? null : new OBBond(cPtr, false);
    return ret;
  }

  public OBBond GetBond(int a, int b) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_GetBond__SWIG_1(swigCPtr, a, b);
    OBBond ret = (cPtr == IntPtr.Zero) ? null : new OBBond(cPtr, false);
    return ret;
  }

  public OBBond GetBond(OBAtom bgn, OBAtom end) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_GetBond__SWIG_2(swigCPtr, OBAtom.getCPtr(bgn), OBAtom.getCPtr(end));
    OBBond ret = (cPtr == IntPtr.Zero) ? null : new OBBond(cPtr, false);
    return ret;
  }

  public OBResidue GetResidue(int idx) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_GetResidue(swigCPtr, idx);
    OBResidue ret = (cPtr == IntPtr.Zero) ? null : new OBResidue(cPtr, false);
    return ret;
  }

  public vectorpInternalCoord GetInternalCoord() {
    vectorpInternalCoord ret = new vectorpInternalCoord(openbabelPINVOKE.OBMol_GetInternalCoord(swigCPtr), true);
    return ret;
  }

  public double GetTorsion(int arg0, int arg1, int arg2, int arg3) {
    double ret = openbabelPINVOKE.OBMol_GetTorsion__SWIG_0(swigCPtr, arg0, arg1, arg2, arg3);
    return ret;
  }

  public double GetTorsion(OBAtom a, OBAtom b, OBAtom c, OBAtom d) {
    double ret = openbabelPINVOKE.OBMol_GetTorsion__SWIG_1(swigCPtr, OBAtom.getCPtr(a), OBAtom.getCPtr(b), OBAtom.getCPtr(c), OBAtom.getCPtr(d));
    return ret;
  }

  public double GetAngle(OBAtom a, OBAtom b, OBAtom c) {
    double ret = openbabelPINVOKE.OBMol_GetAngle(swigCPtr, OBAtom.getCPtr(a), OBAtom.getCPtr(b), OBAtom.getCPtr(c));
    return ret;
  }

  public string GetFormula() {
    string ret = openbabelPINVOKE.OBMol_GetFormula(swigCPtr);
    return ret;
  }

  public string GetSpacedFormula(int ones, string sp, bool implicitH) {
    string ret = openbabelPINVOKE.OBMol_GetSpacedFormula__SWIG_0(swigCPtr, ones, sp, implicitH);
    return ret;
  }

  public string GetSpacedFormula(int ones, string sp) {
    string ret = openbabelPINVOKE.OBMol_GetSpacedFormula__SWIG_1(swigCPtr, ones, sp);
    return ret;
  }

  public string GetSpacedFormula(int ones) {
    string ret = openbabelPINVOKE.OBMol_GetSpacedFormula__SWIG_2(swigCPtr, ones);
    return ret;
  }

  public string GetSpacedFormula() {
    string ret = openbabelPINVOKE.OBMol_GetSpacedFormula__SWIG_3(swigCPtr);
    return ret;
  }

  public double GetEnergy() {
    double ret = openbabelPINVOKE.OBMol_GetEnergy__SWIG_0(swigCPtr);
    return ret;
  }

  public double GetMolWt(bool implicitH) {
    double ret = openbabelPINVOKE.OBMol_GetMolWt__SWIG_0(swigCPtr, implicitH);
    return ret;
  }

  public double GetMolWt() {
    double ret = openbabelPINVOKE.OBMol_GetMolWt__SWIG_1(swigCPtr);
    return ret;
  }

  public double GetExactMass(bool implicitH) {
    double ret = openbabelPINVOKE.OBMol_GetExactMass__SWIG_0(swigCPtr, implicitH);
    return ret;
  }

  public double GetExactMass() {
    double ret = openbabelPINVOKE.OBMol_GetExactMass__SWIG_1(swigCPtr);
    return ret;
  }

  public int GetTotalCharge() {
    int ret = openbabelPINVOKE.OBMol_GetTotalCharge(swigCPtr);
    return ret;
  }

  public uint GetTotalSpinMultiplicity() {
    uint ret = openbabelPINVOKE.OBMol_GetTotalSpinMultiplicity(swigCPtr);
    return ret;
  }

  public ushort GetDimension() {
    ushort ret = openbabelPINVOKE.OBMol_GetDimension(swigCPtr);
    return ret;
  }

  public double_array GetCoordinates() {
	IntPtr cPtr = openbabelPINVOKE.OBMol_GetCoordinates(swigCPtr);
	SWIGTYPE_p_double ret = null;
	if (cPtr != IntPtr.Zero)
	{
        ret = new SWIGTYPE_p_double(cPtr,true);
	}
	return double_array.frompointer(ret);
}

  public vectorpRing GetSSSR() {
    vectorpRing ret = new vectorpRing(openbabelPINVOKE.OBMol_GetSSSR(swigCPtr), false);
    return ret;
  }

  public bool AutomaticFormalCharge() {
    bool ret = openbabelPINVOKE.OBMol_AutomaticFormalCharge(swigCPtr);
    return ret;
  }

  public bool AutomaticPartialCharge() {
    bool ret = openbabelPINVOKE.OBMol_AutomaticPartialCharge(swigCPtr);
    return ret;
  }

  public void SetTitle(string title) {
    openbabelPINVOKE.OBMol_SetTitle__SWIG_0(swigCPtr, title);
  }

  public void SetTitle(SWIGTYPE_p_std__string title) {
    openbabelPINVOKE.OBMol_SetTitle__SWIG_1(swigCPtr, SWIGTYPE_p_std__string.getCPtr(title));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetFormula(string molFormula) {
    openbabelPINVOKE.OBMol_SetFormula(swigCPtr, molFormula);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetEnergy(double energy) {
    openbabelPINVOKE.OBMol_SetEnergy(swigCPtr, energy);
  }

  public void SetDimension(ushort d) {
    openbabelPINVOKE.OBMol_SetDimension(swigCPtr, d);
  }

  public void SetTotalCharge(int charge) {
    openbabelPINVOKE.OBMol_SetTotalCharge(swigCPtr, charge);
  }

  public void SetTotalSpinMultiplicity(uint spinMultiplicity) {
    openbabelPINVOKE.OBMol_SetTotalSpinMultiplicity(swigCPtr, spinMultiplicity);
  }

  public void SetInternalCoord(vectorpInternalCoord int_coord) {
    openbabelPINVOKE.OBMol_SetInternalCoord(swigCPtr, vectorpInternalCoord.getCPtr(int_coord));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetAutomaticFormalCharge(bool val) {
    openbabelPINVOKE.OBMol_SetAutomaticFormalCharge(swigCPtr, val);
  }

  public void SetAutomaticPartialCharge(bool val) {
    openbabelPINVOKE.OBMol_SetAutomaticPartialCharge(swigCPtr, val);
  }

  public void SetAromaticPerceived() {
    openbabelPINVOKE.OBMol_SetAromaticPerceived(swigCPtr);
  }

  public void SetSSSRPerceived() {
    openbabelPINVOKE.OBMol_SetSSSRPerceived(swigCPtr);
  }

  public void SetRingAtomsAndBondsPerceived() {
    openbabelPINVOKE.OBMol_SetRingAtomsAndBondsPerceived(swigCPtr);
  }

  public void SetAtomTypesPerceived() {
    openbabelPINVOKE.OBMol_SetAtomTypesPerceived(swigCPtr);
  }

  public void SetRingTypesPerceived() {
    openbabelPINVOKE.OBMol_SetRingTypesPerceived(swigCPtr);
  }

  public void SetChainsPerceived() {
    openbabelPINVOKE.OBMol_SetChainsPerceived(swigCPtr);
  }

  public void SetChiralityPerceived() {
    openbabelPINVOKE.OBMol_SetChiralityPerceived(swigCPtr);
  }

  public void SetPartialChargesPerceived() {
    openbabelPINVOKE.OBMol_SetPartialChargesPerceived(swigCPtr);
  }

  public void SetHybridizationPerceived() {
    openbabelPINVOKE.OBMol_SetHybridizationPerceived(swigCPtr);
  }

  public void SetImplicitValencePerceived() {
    openbabelPINVOKE.OBMol_SetImplicitValencePerceived(swigCPtr);
  }

  public void SetKekulePerceived() {
    openbabelPINVOKE.OBMol_SetKekulePerceived(swigCPtr);
  }

  public void SetClosureBondsPerceived() {
    openbabelPINVOKE.OBMol_SetClosureBondsPerceived(swigCPtr);
  }

  public void SetHydrogensAdded() {
    openbabelPINVOKE.OBMol_SetHydrogensAdded(swigCPtr);
  }

  public void SetCorrectedForPH() {
    openbabelPINVOKE.OBMol_SetCorrectedForPH(swigCPtr);
  }

  public void SetAromaticCorrected() {
    openbabelPINVOKE.OBMol_SetAromaticCorrected(swigCPtr);
  }

  public void SetSpinMultiplicityAssigned() {
    openbabelPINVOKE.OBMol_SetSpinMultiplicityAssigned(swigCPtr);
  }

  public void SetFlags(int flags) {
    openbabelPINVOKE.OBMol_SetFlags(swigCPtr, flags);
  }

  public void UnsetAromaticPerceived() {
    openbabelPINVOKE.OBMol_UnsetAromaticPerceived(swigCPtr);
  }

  public void UnsetSSSRPerceived() {
    openbabelPINVOKE.OBMol_UnsetSSSRPerceived(swigCPtr);
  }

  public void UnsetRingTypesPerceived() {
    openbabelPINVOKE.OBMol_UnsetRingTypesPerceived(swigCPtr);
  }

  public void UnsetPartialChargesPerceived() {
    openbabelPINVOKE.OBMol_UnsetPartialChargesPerceived(swigCPtr);
  }

  public void UnsetImplicitValencePerceived() {
    openbabelPINVOKE.OBMol_UnsetImplicitValencePerceived(swigCPtr);
  }

  public void UnsetHydrogensAdded() {
    openbabelPINVOKE.OBMol_UnsetHydrogensAdded(swigCPtr);
  }

  public void UnsetFlag(int flag) {
    openbabelPINVOKE.OBMol_UnsetFlag(swigCPtr, flag);
  }

  public override OBBase DoTransformations(SWIGTYPE_p_std__mapT_std__string_std__string_t pOptions) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_DoTransformations(swigCPtr, SWIGTYPE_p_std__mapT_std__string_std__string_t.getCPtr(pOptions));
    OBBase ret = (cPtr == IntPtr.Zero) ? null : new OBBase(cPtr, false);
    return ret;
  }

  public new static string ClassDescription() {
    string ret = openbabelPINVOKE.OBMol_ClassDescription();
    return ret;
  }

  public override bool Clear() {
    bool ret = openbabelPINVOKE.OBMol_Clear(swigCPtr);
    return ret;
  }

  public void RenumberAtoms(vectorpAtom arg0) {
    openbabelPINVOKE.OBMol_RenumberAtoms(swigCPtr, vectorpAtom.getCPtr(arg0));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void SetCoordinates(double_array c) {
     SWIGTYPE_p_double tempc = c.cast();
    {
      openbabelPINVOKE.OBMol_SetCoordinates(swigCPtr, SWIGTYPE_p_double.getCPtr(tempc));
    }
  }

  public void ToInertialFrame(int conf, double_array rmat) {
     SWIGTYPE_p_double temprmat = rmat.cast();
    {
      openbabelPINVOKE.OBMol_ToInertialFrame__SWIG_0(swigCPtr, conf, SWIGTYPE_p_double.getCPtr(temprmat));
    }
  }

  public void ToInertialFrame() {
    openbabelPINVOKE.OBMol_ToInertialFrame__SWIG_1(swigCPtr);
  }

  public void Translate(OBVector3 v) {
    openbabelPINVOKE.OBMol_Translate__SWIG_0(swigCPtr, OBVector3.getCPtr(v));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void Translate(OBVector3 v, int conf) {
    openbabelPINVOKE.OBMol_Translate__SWIG_1(swigCPtr, OBVector3.getCPtr(v), conf);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void Rotate(SWIGTYPE_p_a_3__double u) {
    openbabelPINVOKE.OBMol_Rotate__SWIG_0(swigCPtr, SWIGTYPE_p_a_3__double.getCPtr(u));
  }

  public void Rotate(SWIGTYPE_p_double m) {
    openbabelPINVOKE.OBMol_Rotate__SWIG_1(swigCPtr, SWIGTYPE_p_double.getCPtr(m));
  }

  public void Rotate(SWIGTYPE_p_double m, int nconf) {
    openbabelPINVOKE.OBMol_Rotate__SWIG_2(swigCPtr, SWIGTYPE_p_double.getCPtr(m), nconf);
  }

  public void Center() {
    openbabelPINVOKE.OBMol_Center__SWIG_0(swigCPtr);
  }

  public bool Kekulize() {
    bool ret = openbabelPINVOKE.OBMol_Kekulize(swigCPtr);
    return ret;
  }

  public bool PerceiveKekuleBonds() {
    bool ret = openbabelPINVOKE.OBMol_PerceiveKekuleBonds(swigCPtr);
    return ret;
  }

  public void NewPerceiveKekuleBonds() {
    openbabelPINVOKE.OBMol_NewPerceiveKekuleBonds(swigCPtr);
  }

  public bool DeleteHydrogens() {
    bool ret = openbabelPINVOKE.OBMol_DeleteHydrogens__SWIG_0(swigCPtr);
    return ret;
  }

  public bool DeleteHydrogens(OBAtom arg0) {
    bool ret = openbabelPINVOKE.OBMol_DeleteHydrogens__SWIG_1(swigCPtr, OBAtom.getCPtr(arg0));
    return ret;
  }

  public bool DeleteNonPolarHydrogens() {
    bool ret = openbabelPINVOKE.OBMol_DeleteNonPolarHydrogens(swigCPtr);
    return ret;
  }

  public bool DeleteHydrogen(OBAtom arg0) {
    bool ret = openbabelPINVOKE.OBMol_DeleteHydrogen(swigCPtr, OBAtom.getCPtr(arg0));
    return ret;
  }

  public bool AddHydrogens(bool polaronly, bool correctForPH, double pH) {
    bool ret = openbabelPINVOKE.OBMol_AddHydrogens__SWIG_0(swigCPtr, polaronly, correctForPH, pH);
    return ret;
  }

  public bool AddHydrogens(bool polaronly, bool correctForPH) {
    bool ret = openbabelPINVOKE.OBMol_AddHydrogens__SWIG_1(swigCPtr, polaronly, correctForPH);
    return ret;
  }

  public bool AddHydrogens(bool polaronly) {
    bool ret = openbabelPINVOKE.OBMol_AddHydrogens__SWIG_2(swigCPtr, polaronly);
    return ret;
  }

  public bool AddHydrogens() {
    bool ret = openbabelPINVOKE.OBMol_AddHydrogens__SWIG_3(swigCPtr);
    return ret;
  }

  public bool AddHydrogens(OBAtom arg0) {
    bool ret = openbabelPINVOKE.OBMol_AddHydrogens__SWIG_4(swigCPtr, OBAtom.getCPtr(arg0));
    return ret;
  }

  public bool AddPolarHydrogens() {
    bool ret = openbabelPINVOKE.OBMol_AddPolarHydrogens(swigCPtr);
    return ret;
  }

  public bool StripSalts(int threshold) {
    bool ret = openbabelPINVOKE.OBMol_StripSalts(swigCPtr, threshold);
    return ret;
  }

  public vectorMol Separate(int StartIndex) {
    vectorMol ret = new vectorMol(openbabelPINVOKE.OBMol_Separate__SWIG_0(swigCPtr, StartIndex), true);
    return ret;
  }

  public vectorMol Separate() {
    vectorMol ret = new vectorMol(openbabelPINVOKE.OBMol_Separate__SWIG_1(swigCPtr), true);
    return ret;
  }

  public bool GetNextFragment(OBMolAtomDFSIter iter, OBMol newMol) {
    bool ret = openbabelPINVOKE.OBMol_GetNextFragment(swigCPtr, OBMolAtomDFSIter.getCPtr(iter), OBMol.getCPtr(newMol));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public bool ConvertDativeBonds() {
    bool ret = openbabelPINVOKE.OBMol_ConvertDativeBonds(swigCPtr);
    return ret;
  }

  public bool CorrectForPH(double pH) {
    bool ret = openbabelPINVOKE.OBMol_CorrectForPH__SWIG_0(swigCPtr, pH);
    return ret;
  }

  public bool CorrectForPH() {
    bool ret = openbabelPINVOKE.OBMol_CorrectForPH__SWIG_1(swigCPtr);
    return ret;
  }

  public bool AssignSpinMultiplicity(bool NoImplicitH) {
    bool ret = openbabelPINVOKE.OBMol_AssignSpinMultiplicity__SWIG_0(swigCPtr, NoImplicitH);
    return ret;
  }

  public bool AssignSpinMultiplicity() {
    bool ret = openbabelPINVOKE.OBMol_AssignSpinMultiplicity__SWIG_1(swigCPtr);
    return ret;
  }

  public OBVector3 Center(int nconf) {
    OBVector3 ret = new OBVector3(openbabelPINVOKE.OBMol_Center__SWIG_1(swigCPtr, nconf), true);
    return ret;
  }

  public void SetTorsion(OBAtom arg0, OBAtom arg1, OBAtom arg2, OBAtom arg3, double ang) {
    openbabelPINVOKE.OBMol_SetTorsion(swigCPtr, OBAtom.getCPtr(arg0), OBAtom.getCPtr(arg1), OBAtom.getCPtr(arg2), OBAtom.getCPtr(arg3), ang);
  }

  public void FindSSSR() {
    openbabelPINVOKE.OBMol_FindSSSR(swigCPtr);
  }

  public void FindRingAtomsAndBonds() {
    openbabelPINVOKE.OBMol_FindRingAtomsAndBonds(swigCPtr);
  }

  public void FindChiralCenters() {
    openbabelPINVOKE.OBMol_FindChiralCenters(swigCPtr);
  }

  public void FindChildren(vectorInt children, int bgnIdx, int endIdx) {
    openbabelPINVOKE.OBMol_FindChildren__SWIG_0(swigCPtr, vectorInt.getCPtr(children), bgnIdx, endIdx);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void FindChildren(vectorpAtom children, OBAtom bgn, OBAtom end) {
    openbabelPINVOKE.OBMol_FindChildren__SWIG_1(swigCPtr, vectorpAtom.getCPtr(children), OBAtom.getCPtr(bgn), OBAtom.getCPtr(end));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void FindLargestFragment(OBBitVec frag) {
    openbabelPINVOKE.OBMol_FindLargestFragment(swigCPtr, OBBitVec.getCPtr(frag));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void ContigFragList(vvInt arg0) {
    openbabelPINVOKE.OBMol_ContigFragList(swigCPtr, vvInt.getCPtr(arg0));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void Align(OBAtom arg0, OBAtom arg1, OBVector3 arg2, OBVector3 arg3) {
    openbabelPINVOKE.OBMol_Align(swigCPtr, OBAtom.getCPtr(arg0), OBAtom.getCPtr(arg1), OBVector3.getCPtr(arg2), OBVector3.getCPtr(arg3));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void ConnectTheDots() {
    openbabelPINVOKE.OBMol_ConnectTheDots(swigCPtr);
  }

  public void PerceiveBondOrders() {
    openbabelPINVOKE.OBMol_PerceiveBondOrders(swigCPtr);
  }

  public void FindAngles() {
    openbabelPINVOKE.OBMol_FindAngles(swigCPtr);
  }

  public void FindTorsions() {
    openbabelPINVOKE.OBMol_FindTorsions(swigCPtr);
  }

  public bool GetGTDVector(vectorInt arg0) {
    bool ret = openbabelPINVOKE.OBMol_GetGTDVector(swigCPtr, vectorInt.getCPtr(arg0));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public void GetGIVector(vectorUnsignedInt arg0) {
    openbabelPINVOKE.OBMol_GetGIVector(swigCPtr, vectorUnsignedInt.getCPtr(arg0));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void GetGIDVector(vectorUnsignedInt arg0) {
    openbabelPINVOKE.OBMol_GetGIDVector(swigCPtr, vectorUnsignedInt.getCPtr(arg0));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public bool Has2D() {
    bool ret = openbabelPINVOKE.OBMol_Has2D(swigCPtr);
    return ret;
  }

  public bool Has3D() {
    bool ret = openbabelPINVOKE.OBMol_Has3D(swigCPtr);
    return ret;
  }

  public bool HasNonZeroCoords() {
    bool ret = openbabelPINVOKE.OBMol_HasNonZeroCoords(swigCPtr);
    return ret;
  }

  public bool HasAromaticPerceived() {
    bool ret = openbabelPINVOKE.OBMol_HasAromaticPerceived(swigCPtr);
    return ret;
  }

  public bool HasSSSRPerceived() {
    bool ret = openbabelPINVOKE.OBMol_HasSSSRPerceived(swigCPtr);
    return ret;
  }

  public bool HasRingAtomsAndBondsPerceived() {
    bool ret = openbabelPINVOKE.OBMol_HasRingAtomsAndBondsPerceived(swigCPtr);
    return ret;
  }

  public bool HasAtomTypesPerceived() {
    bool ret = openbabelPINVOKE.OBMol_HasAtomTypesPerceived(swigCPtr);
    return ret;
  }

  public bool HasRingTypesPerceived() {
    bool ret = openbabelPINVOKE.OBMol_HasRingTypesPerceived(swigCPtr);
    return ret;
  }

  public bool HasChiralityPerceived() {
    bool ret = openbabelPINVOKE.OBMol_HasChiralityPerceived(swigCPtr);
    return ret;
  }

  public bool HasPartialChargesPerceived() {
    bool ret = openbabelPINVOKE.OBMol_HasPartialChargesPerceived(swigCPtr);
    return ret;
  }

  public bool HasHybridizationPerceived() {
    bool ret = openbabelPINVOKE.OBMol_HasHybridizationPerceived(swigCPtr);
    return ret;
  }

  public bool HasImplicitValencePerceived() {
    bool ret = openbabelPINVOKE.OBMol_HasImplicitValencePerceived(swigCPtr);
    return ret;
  }

  public bool HasKekulePerceived() {
    bool ret = openbabelPINVOKE.OBMol_HasKekulePerceived(swigCPtr);
    return ret;
  }

  public bool HasClosureBondsPerceived() {
    bool ret = openbabelPINVOKE.OBMol_HasClosureBondsPerceived(swigCPtr);
    return ret;
  }

  public bool HasChainsPerceived() {
    bool ret = openbabelPINVOKE.OBMol_HasChainsPerceived(swigCPtr);
    return ret;
  }

  public bool HasHydrogensAdded() {
    bool ret = openbabelPINVOKE.OBMol_HasHydrogensAdded(swigCPtr);
    return ret;
  }

  public bool HasAromaticCorrected() {
    bool ret = openbabelPINVOKE.OBMol_HasAromaticCorrected(swigCPtr);
    return ret;
  }

  public bool IsCorrectedForPH() {
    bool ret = openbabelPINVOKE.OBMol_IsCorrectedForPH(swigCPtr);
    return ret;
  }

  public bool HasSpinMultiplicityAssigned() {
    bool ret = openbabelPINVOKE.OBMol_HasSpinMultiplicityAssigned(swigCPtr);
    return ret;
  }

  public bool IsChiral() {
    bool ret = openbabelPINVOKE.OBMol_IsChiral(swigCPtr);
    return ret;
  }

  public bool Empty() {
    bool ret = openbabelPINVOKE.OBMol_Empty(swigCPtr);
    return ret;
  }

  public int NumConformers() {
    int ret = openbabelPINVOKE.OBMol_NumConformers(swigCPtr);
    return ret;
  }

  public void SetConformers(SWIGTYPE_p_std__vectorT_double_p_t v) {
    openbabelPINVOKE.OBMol_SetConformers(swigCPtr, SWIGTYPE_p_std__vectorT_double_p_t.getCPtr(v));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public void AddConformer(double_array f) {
     SWIGTYPE_p_double tempf = f.cast();
    {
      openbabelPINVOKE.OBMol_AddConformer(swigCPtr, SWIGTYPE_p_double.getCPtr(tempf));
    }
  }

  public void SetConformer(int i) {
    openbabelPINVOKE.OBMol_SetConformer(swigCPtr, i);
  }

  public void CopyConformer(double_array c, int nconf) {
     SWIGTYPE_p_double tempc = c.cast();
    {
      openbabelPINVOKE.OBMol_CopyConformer(swigCPtr, SWIGTYPE_p_double.getCPtr(tempc), nconf);
    }
  }

  public void DeleteConformer(int nconf) {
    openbabelPINVOKE.OBMol_DeleteConformer(swigCPtr, nconf);
  }

  public double_array GetConformer(int i) {
	IntPtr cPtr = openbabelPINVOKE.OBMol_GetConformer(swigCPtr, i);
	SWIGTYPE_p_double ret = null;
	if (cPtr != IntPtr.Zero)
	{
        ret = new SWIGTYPE_p_double(cPtr,true);
	}
	return double_array.frompointer(ret);
}

  public void SetEnergies(vectorDouble energies) {
    openbabelPINVOKE.OBMol_SetEnergies(swigCPtr, vectorDouble.getCPtr(energies));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
  }

  public vectorDouble GetEnergies() {
    vectorDouble ret = new vectorDouble(openbabelPINVOKE.OBMol_GetEnergies(swigCPtr), true);
    return ret;
  }

  public double GetEnergy(int ci) {
    double ret = openbabelPINVOKE.OBMol_GetEnergy__SWIG_1(swigCPtr, ci);
    return ret;
  }

  public double_array BeginConformer(SWIGTYPE_p_std__vectorT_double_p_t__iterator i) {
	IntPtr cPtr = openbabelPINVOKE.OBMol_BeginConformer(swigCPtr, SWIGTYPE_p_std__vectorT_double_p_t__iterator.getCPtr(i));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
	SWIGTYPE_p_double ret = null;
	if (cPtr != IntPtr.Zero)
	{
        ret = new SWIGTYPE_p_double(cPtr,true);
	}
	return double_array.frompointer(ret);
}

  public double_array NextConformer(SWIGTYPE_p_std__vectorT_double_p_t__iterator i) {
	IntPtr cPtr = openbabelPINVOKE.OBMol_NextConformer(swigCPtr, SWIGTYPE_p_std__vectorT_double_p_t__iterator.getCPtr(i));
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
	SWIGTYPE_p_double ret = null;
	if (cPtr != IntPtr.Zero)
	{
        ret = new SWIGTYPE_p_double(cPtr,true);
	}
	return double_array.frompointer(ret);
}

  public SWIGTYPE_p_std__vectorT_double_p_t GetConformers() {
    SWIGTYPE_p_std__vectorT_double_p_t ret = new SWIGTYPE_p_std__vectorT_double_p_t(openbabelPINVOKE.OBMol_GetConformers(swigCPtr), false);
    return ret;
  }

  public SWIGTYPE_p_std__vectorT_OpenBabel__OBAtom_p_t__iterator BeginAtoms() {
    SWIGTYPE_p_std__vectorT_OpenBabel__OBAtom_p_t__iterator ret = new SWIGTYPE_p_std__vectorT_OpenBabel__OBAtom_p_t__iterator(openbabelPINVOKE.OBMol_BeginAtoms(swigCPtr), true);
    return ret;
  }

  public SWIGTYPE_p_std__vectorT_OpenBabel__OBAtom_p_t__iterator EndAtoms() {
    SWIGTYPE_p_std__vectorT_OpenBabel__OBAtom_p_t__iterator ret = new SWIGTYPE_p_std__vectorT_OpenBabel__OBAtom_p_t__iterator(openbabelPINVOKE.OBMol_EndAtoms(swigCPtr), true);
    return ret;
  }

  public SWIGTYPE_p_std__vectorT_OpenBabel__OBBond_p_t__iterator BeginBonds() {
    SWIGTYPE_p_std__vectorT_OpenBabel__OBBond_p_t__iterator ret = new SWIGTYPE_p_std__vectorT_OpenBabel__OBBond_p_t__iterator(openbabelPINVOKE.OBMol_BeginBonds(swigCPtr), true);
    return ret;
  }

  public SWIGTYPE_p_std__vectorT_OpenBabel__OBBond_p_t__iterator EndBonds() {
    SWIGTYPE_p_std__vectorT_OpenBabel__OBBond_p_t__iterator ret = new SWIGTYPE_p_std__vectorT_OpenBabel__OBBond_p_t__iterator(openbabelPINVOKE.OBMol_EndBonds(swigCPtr), true);
    return ret;
  }

  public SWIGTYPE_p_std__vectorT_OpenBabel__OBResidue_p_t__iterator BeginResidues() {
    SWIGTYPE_p_std__vectorT_OpenBabel__OBResidue_p_t__iterator ret = new SWIGTYPE_p_std__vectorT_OpenBabel__OBResidue_p_t__iterator(openbabelPINVOKE.OBMol_BeginResidues(swigCPtr), true);
    return ret;
  }

  public SWIGTYPE_p_std__vectorT_OpenBabel__OBResidue_p_t__iterator EndResidues() {
    SWIGTYPE_p_std__vectorT_OpenBabel__OBResidue_p_t__iterator ret = new SWIGTYPE_p_std__vectorT_OpenBabel__OBResidue_p_t__iterator(openbabelPINVOKE.OBMol_EndResidues(swigCPtr), true);
    return ret;
  }

  public OBAtom BeginAtom(SWIGTYPE_p_std__vectorT_OpenBabel__OBAtom_p_t__iterator i) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_BeginAtom(swigCPtr, SWIGTYPE_p_std__vectorT_OpenBabel__OBAtom_p_t__iterator.getCPtr(i));
    OBAtom ret = (cPtr == IntPtr.Zero) ? null : new OBAtom(cPtr, false);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public OBAtom NextAtom(SWIGTYPE_p_std__vectorT_OpenBabel__OBAtom_p_t__iterator i) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_NextAtom(swigCPtr, SWIGTYPE_p_std__vectorT_OpenBabel__OBAtom_p_t__iterator.getCPtr(i));
    OBAtom ret = (cPtr == IntPtr.Zero) ? null : new OBAtom(cPtr, false);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public OBBond BeginBond(SWIGTYPE_p_std__vectorT_OpenBabel__OBBond_p_t__iterator i) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_BeginBond(swigCPtr, SWIGTYPE_p_std__vectorT_OpenBabel__OBBond_p_t__iterator.getCPtr(i));
    OBBond ret = (cPtr == IntPtr.Zero) ? null : new OBBond(cPtr, false);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public OBBond NextBond(SWIGTYPE_p_std__vectorT_OpenBabel__OBBond_p_t__iterator i) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_NextBond(swigCPtr, SWIGTYPE_p_std__vectorT_OpenBabel__OBBond_p_t__iterator.getCPtr(i));
    OBBond ret = (cPtr == IntPtr.Zero) ? null : new OBBond(cPtr, false);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public OBResidue BeginResidue(SWIGTYPE_p_std__vectorT_OpenBabel__OBResidue_p_t__iterator i) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_BeginResidue(swigCPtr, SWIGTYPE_p_std__vectorT_OpenBabel__OBResidue_p_t__iterator.getCPtr(i));
    OBResidue ret = (cPtr == IntPtr.Zero) ? null : new OBResidue(cPtr, false);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public OBResidue NextResidue(SWIGTYPE_p_std__vectorT_OpenBabel__OBResidue_p_t__iterator i) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_NextResidue(swigCPtr, SWIGTYPE_p_std__vectorT_OpenBabel__OBResidue_p_t__iterator.getCPtr(i));
    OBResidue ret = (cPtr == IntPtr.Zero) ? null : new OBResidue(cPtr, false);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public OBInternalCoord BeginInternalCoord(SWIGTYPE_p_std__vectorT_OpenBabel__OBInternalCoord_p_t__iterator i) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_BeginInternalCoord(swigCPtr, SWIGTYPE_p_std__vectorT_OpenBabel__OBInternalCoord_p_t__iterator.getCPtr(i));
    OBInternalCoord ret = (cPtr == IntPtr.Zero) ? null : new OBInternalCoord(cPtr, false);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

  public OBInternalCoord NextInternalCoord(SWIGTYPE_p_std__vectorT_OpenBabel__OBInternalCoord_p_t__iterator i) {
    IntPtr cPtr = openbabelPINVOKE.OBMol_NextInternalCoord(swigCPtr, SWIGTYPE_p_std__vectorT_OpenBabel__OBInternalCoord_p_t__iterator.getCPtr(i));
    OBInternalCoord ret = (cPtr == IntPtr.Zero) ? null : new OBInternalCoord(cPtr, false);
    if (openbabelPINVOKE.SWIGPendingException.Pending) throw openbabelPINVOKE.SWIGPendingException.Retrieve();
    return ret;
  }

}

}