src/mmdb_mmcif_.h

Go to the documentation of this file.

//  $Id: mmdb_mmcif_.h $
//  =================================================================
//
//   CCP4 Coordinate Library: support of coordinate-related
//   functionality in protein crystallography applications.
//
//   Copyright (C) Eugene Krissinel 2000-2013.
//
//    This library is free software: you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License version 3, modified in accordance with the provisions
//    of the license to address the requirements of UK law.
//
//    You should have received a copy of the modified GNU Lesser
//    General Public License along with this library. If not, copies
//    may be downloaded from http://www.ccp4.ac.uk/ccp4license.php
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU Lesser General Public License for more details.
//
//  =================================================================
//
//    12.09.13   <--  Date of Last Modification.
//                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//  -----------------------------------------------------------------
//
//  **** Module  :  MMDB_MMCIF <interface>
//       ~~~~~~~~~
//  **** Project :  MacroMolecular Data Base (MMDB)
//       ~~~~~~~~~
//  **** Classes :  mmdb::mmcif::Category ( mmCIF category    )
//       ~~~~~~~~~  mmdb::mmcif::Struct   ( mmCIF structure   )
//                  mmdb::mmcif::Loop     ( mmCIF loop        )
//                  mmdb::mmcif::Data     ( mmCIF data block  )
//                  mmdb::mmcif::File     ( mmCIF file        )
//
//  (C) E. Krissinel 2000-2013
//
//  =================================================================
//


#ifndef __MMDB_MMCIF__
#define __MMDB_MMCIF__


#include "mmdb_io_stream.h"

namespace mmdb  {

  namespace mmcif  {


    //  ======================  Category  ==========================

    enum MMCIF_ITEM  {
      MMCIF_Category = 0,
      MMCIF_Struct   = 1,
      MMCIF_Loop     = 2,
      MMCIF_Data     = 3
    };

    DefineClass(Category);
    DefineStreamFunctions(Category);


    class Category : public io::Stream  {

      friend class Data;

      public :

        Category ();

        Category ( cpstr N );

        Category ( io::RPStream Object );

        ~Category();

        inline pstr   GetCategoryName() { return name; }

        void   SetCategoryName ( cpstr N );

        virtual MMCIF_ITEM GetCategoryID() { return MMCIF_Category; }

        virtual void WriteMMCIF ( io::RFile ) {}

        virtual void Optimize();

        void  Sort();

        int   GetTagNo ( cpstr ttag );

        int   AddTag ( cpstr ttag );

        int   GetNofTags() { return nTags; }

        pstr  GetTag ( int tagNo );  // 0..nTags-1

        void  PrintTags();

        bool CheckTags ( cpstr * tagList );

        virtual void Copy ( PCategory Category );

        void  write ( io::RFile f );

        void  read  ( io::RFile f );

      protected:
        int      nTags;
        pstr     name;
        psvector tag;
        ivector  index;
        int      nAllocTags;

        void          InitCategory    ();
        virtual void  FreeMemory      ();
        void          ExpandTags      ( int nTagsNew );
        void          PutCategoryName ( cpstr newName );

    };



    //  ======================  Struct  ============================

    DefineClass(Struct);
    DefineStreamFunctions(Struct);

    extern const int CIF_NODATA_DOT;
    extern const int CIF_NODATA_QUESTION;
    extern cpstr     CIF_NODATA_DOT_FIELD;
    extern cpstr     CIF_NODATA_QUESTION_FIELD;


    class Struct : public Category  {

      public :

        Struct ();

        Struct ( cpstr N );

        Struct ( io::RPStream Object );

        ~Struct();

        void AddField ( cpstr F, cpstr T, bool Concatenate=false );

        MMCIF_ITEM  GetCategoryID()  { return MMCIF_Struct; }

        void Optimize();

        pstr GetField ( int tagNo );  // 0..nTags-1

        int  GetString ( pstr & S, cpstr TName, bool Remove=false );

        pstr GetString ( cpstr TName, int & RC ); // NULL if TName
                                                         // is not there

        int  DeleteField ( cpstr TName );  // <0 the field was not there

        int  GetReal ( realtype & R, cpstr TName, bool Remove=false );

        int  GetInteger ( int & I, cpstr TName, bool Remove=false );

        void PutString   ( cpstr S, cpstr TName,
                           bool NonBlankOnly=false );

        void PutDate     ( cpstr T );

        void PutNoData   ( int NoDataType, cpstr T  );

        void PutReal     ( realtype R, cpstr TName, int prec=8 );

        void PutReal     ( realtype R, cpstr TName, cpstr format );

        void PutInteger  ( int      I, cpstr TName );

        bool WriteMMCIFStruct ( cpstr FName,
                                io::GZ_MODE gzipMode=io::GZM_CHECK );

        void    WriteMMCIF ( io::RFile f  );

        void Copy ( PCategory Struct );

        void write ( io::RFile f );

        void read  ( io::RFile f );

      protected:
        psvector field;

        void InitStruct();
        void FreeMemory();

    };



    //  ======================  Loop  ==============================

    DefineClass(Loop);
    DefineStreamFunctions(Loop);


    class Loop : public Category  {

      friend class Data;

      public :

        Loop ();

        Loop ( cpstr N );

        Loop ( io::RPStream Object );

        ~Loop();

        void  AddLoopTag ( cpstr T, bool Remove=true );

        void  AddString ( cpstr S, bool NonBlankOnly=false );

        void  AddNoData ( int NoDataType );

        void  AddReal ( realtype R, int prec=8 );

        void  AddReal ( realtype R, cpstr format );

        void  AddInteger ( int I );

        int   GetLoopLength() { return nRows; }

        pstr  GetField ( int rowNo, int tagNo );

        int   GetString ( pstr & S, cpstr TName, int nrow,
                                           bool Remove=false );

        pstr  GetString    ( cpstr TName, int nrow, int & RC );

        void  CopyString   ( pstr  buf,   int maxlength,
                             cpstr TName, int nrow, int & RC );

        int   DeleteField  ( cpstr TName, int nrow );

        int   DeleteRow    ( int nrow );

        int   GetReal ( realtype & R, cpstr TName, int nrow,
                                           bool Remove=false );

        void  CopyReal ( realtype & R, cpstr TName, int nrow, int & RC );

        void  CopyInteger ( int & I, cpstr TName, int nrow, int & RC );

        int   GetInteger   ( int & I, cpstr TName, int nrow,
                                           bool Remove=false );

        int  GetSVector ( psvector & S, cpstr TName,
                          int i1=0, int i2=MaxInt4,
                          bool Remove=false );

        int  GetRVector ( rvector  & R, cpstr TName,
                          int i1=0, int i2=MaxInt4,
                          bool Remove=false );

        int  GetIVector ( ivector  & I, cpstr TName,
                          int i1=0, int i2=MaxInt4,
                          bool Remove=false );

        void  PutString ( cpstr S, cpstr T, int nrow );

        void  PutNoData ( int NoDataType, cpstr T, int nrow );

        void  PutReal ( realtype R, cpstr T, int nrow, int prec=8 );

        void  PutReal ( realtype R, cpstr T, int nrow, cpstr format );

        void  PutInteger ( int I, cpstr T, int nrow );

        void  PutSVector   ( psvector S, cpstr T, int i1, int i2 );

        void  PutRVector   ( rvector  R, cpstr T, int i1, int i2,
                                                       int prec=8 );

        void  PutIVector   ( ivector  I, cpstr T, int i1, int i2 );

        MMCIF_ITEM  GetCategoryID() { return MMCIF_Loop; }

        void  Optimize();

        bool WriteMMCIFLoop ( cpstr FName,
                              io::GZ_MODE gzipMode=io::GZM_CHECK );

        void  WriteMMCIF ( io::RFile f );

        void  Copy ( PCategory Loop );

        void write ( io::RFile f );

        void read  ( io::RFile f );

      protected:
        int      nRows;
        psmatrix field;
        int      iColumn,nAllocRows;

        void  InitLoop     ();
        void  FreeMemory   ();
        void  DeleteFields ();
        void  ExpandRows   ( int nRowsNew );

    };



    //  ======================  Data  =============================


    //    CIFW are warnings which may be issued on reading the CIF file.
    // Each of them means actually a CIF syntax error.

    enum CIF_WARNING  {
      CIFW_UnrecognizedItems = 0x00000020,
      CIFW_MissingField      = 0x00000040,
      CIFW_EmptyLoop         = 0x00000080,
      CIFW_UnexpectedEOF     = 0x00000100,
      CIFW_LoopFieldMissing  = 0x00000200,
      CIFW_NotAStructure     = 0x00000400,
      CIFW_NotALoop          = 0x00000800,
      CIFW_DuplicateTag      = 0x00001000
    };

    //    CIFRC are return codes from procedures of extracting data from
    // the read CIF file. Negative returns reflect unsuccessful and
    // not accomplished operation.
    enum CIF_RC  {
      CIFRC_Loop           =  2,
      CIFRC_Structure      =  1,
      CIFRC_Ok             =  0,
      CIFRC_StructureNoTag = -1,
      CIFRC_LoopNoTag      = -2,
      CIFRC_NoCategory     = -3,
      CIFRC_WrongFormat    = -4,
      CIFRC_NoTag          = -5,
      CIFRC_NotAStructure  = -6,
      CIFRC_NotALoop       = -7,
      CIFRC_WrongIndex     = -8,
      CIFRC_NoField        = -9,
      CIFRC_Created        = -12,
      CIFRC_CantOpenFile   = -13,
      CIFRC_NoDataLine     = -14,
      CIFRC_NoData         = -15
    };

    //
    //  Functional flags:
    //  ~~~~~~~~~~~~~~~~~
    //
    //  CIFFL_PrintWarnings      when reading CIF file, all warning
    //                           messages will be printed. If the flag
    //                           is off, the warnings will be bit-encoded
    //                           in the return code
    //  CIFFL_StopOnWarnings     reading CIF file will stop at first
    //                           warning issued
    //  CIFFL_SuggestCategories  allows reading CIF file with loops having
    //                           no categories. Hidden category names
    //                           will be automatically generated for
    //                           internal consistency of the system.
    //                           These names will not appear in output.
    //                           As these names are hidden, they cannot
    //                           be used to access data. It is therefore
    //                           assumed that all tags in all loops without
    //                           categories are unique. Simply specify ""
    //                           for category when accessing such data
    //                           (it cannot be accessed through mmcif::Loop,
    //                           but only through mmcif::Data functions
    //                           taking both Category and Tag; note that
    //                           CIFFL_SuggestCategories flag must be on
    //                           while accessing such data).
    //  CIFFL_SuggestTags        allows for identical tags in a category
    //                           (including a hidden category). Hidden
    //                           suffixes to tag names will be generated
    //                           for internal consistency. At present,
    //                           only data for first non-unique tag may be
    //                           accessed.
    //
    enum CIF_FLAG  {
      CIFFL_PrintWarnings     = 0x00000001,
      CIFFL_StopOnWarnings    = 0x00000002,
      CIFFL_SuggestCategories = 0x00000004,
      CIFFL_SuggestTags       = 0x00000008
    };

    DefineClass(Data);
    DefineStreamFunctions(Data);



    class Data : public io::Stream  {

      friend class File;

      public :

        Data ();

        Data ( cpstr N );

        Data ( io::RPStream Object );

        ~Data();


        // -------- General I/O functions

        void  SetPrintWarnings ( bool SPW );

        void  SetStopOnWarning ( bool SOW );

        void  SetFlag ( CIF_FLAG F );

        void  RemoveFlag ( CIF_FLAG F );

        inline int  GetWarnings() { return Warning; }


        void  SetWrongFields ( cpstr *cats, cpstr *tags );


        int  ReadMMCIFData ( cpstr FName,
                             io::GZ_MODE gzipMode=io::GZM_CHECK );


        int  ReadMMCIFData ( io::RFile f, pstr S, int & lcount );

        bool WriteMMCIFData   ( cpstr FName,
                                io::GZ_MODE gzipMode=io::GZM_CHECK );


        void  WriteMMCIF ( io::RFile f );


        // -------- Retrieving data

        inline int   GetNumberOfCategories ()  { return nCategories; }

        PCategory GetCategory ( int categoryNo ); // 0..nCategories-1

        PStruct GetStructure  ( cpstr CName );

        PLoop GetLoop ( cpstr CName );

        PLoop FindLoop ( cpstr * tagList );

        void GetDataName ( pstr & dname, bool Remove=false );

        inline pstr GetDataName()  { return name; }

        //   CheckData(..) returns positive value if the field is in the
        // file:
        //   CIFRC_Structure  category CName is a structure
        //   CIFRC_Loop       category CName is a loop
        // Negative returns mean:
        //   CIFRC_StructureNoTag  category CName is present,
        //                        it is a structure, but it does not
        //                        have tag TName
        //   CIFRC_LoopNoTag       category CName is present,
        //                        it is a loop, but it does not have
        //                        tag TName
        //   CIFRC_NoCategory      category CName is not present.
        // If TName is set to NULL then only the CName is checked and
        // possible returns are CIFRC_Structure, CIFRC_Loop and
        // CIFRC_NoCategory.
        int  CheckData       ( cpstr CName, cpstr TName );

        int  DeleteCategory  ( cpstr CName );
        int  DeleteStructure ( cpstr CName );
        int  DeleteLoop      ( cpstr CName );

        //   Optimize() optimizes the CIF data in memory allocation. It is
        // a good idea to call it once after extraction of data (GetXXXXXX
        // functions) with Remove flag set on has been completed.
        void Optimize();

        //   GetString(..), GetReal(..) and GetInteger(..) return 0 if the
        // requested field was found and successfully converted. Negative
        // returns mean:
        //    CIFRC_WrongFormat   the field was found but failed to convert
        //                        due to improper numeric format
        //    CIFRC_NoTag         category CName was found, but it does not
        //                        have tag TName
        //    CIFRC_NoCategory    category CName was not found
        //    CIFRC_NotAStructure category CName was found, but it is
        //                        a loop rather than a structure.
        //   GetString(..) will try to dispose Dest unless it is assigned
        // NULL value before the call. The string will be then dynamically
        // allocated and copied.
        //   If Remove is set to true, the field will be removed after
        // extraction.
        int  GetString   ( pstr & Dest, cpstr CName, cpstr TName,
                                        bool Remove=false );
        pstr GetString   ( cpstr CName, cpstr TName, int & RC );
        int  DeleteField ( cpstr CName, cpstr TName );
        int  GetReal     ( realtype & R, cpstr CName,
                           cpstr TName, bool Remove=false );
        int  GetInteger  ( int & I, cpstr CName, cpstr TName,
                                    bool Remove=false );

        //   GetLoopLength(..) returns CIFRC_NotALoop if the category CName
        // is not a loop, CIFRC_NoCategory if the category CName is not
        // found. Non-negative returns give the length of the loop (may be
        // 0 if the loop is empty).
        int  GetLoopLength ( cpstr CName );

        //   GetLoopString(..), GetLoopReal(..) and GetLoopInteger(..) act
        // like GetString(..), GetReal(..) and GetInteger(..) above for
        // nrow-th element of the 'loop_' (indexed like 0..N-1 where N
        // is obtained through GetLoopLength(..)). They will return
        // CIFRC_WrongIndex if nrow is out of range.
        //   If Remove is set to true, the field will be removed after
        // extraction.
        int  GetLoopString   ( pstr & Dest, cpstr CName,
                                            cpstr TName, int nrow,
                                            bool Remove=false );
        pstr GetLoopString   ( cpstr CName, cpstr TName,
                               int nrow, int & RC );
        int  DeleteLoopField ( cpstr CName, cpstr TName,
                               int nrow );
        int  GetLoopReal     ( realtype & R, cpstr CName,
                                             cpstr TName, int nrow,
                                             bool Remove=false );
        int  GetLoopInteger  ( int & I, cpstr CName,
                                        cpstr TName, int nrow,
                                        bool Remove=false );

        //   GetLoopSVector(..), GetLoopRVector(..) and GetLoopIVector(..)
        // read CIF 'loop_' data into allocated vectors of strings, reals
        // and integers, correspondingly. The vectors may be deallocated
        // prior to call and assigned NULL, in which case they will be
        // allocated with offsets of i1, which is also the lower index of
        // the 'loop_' data transferred into it. The upper vector index is
        // given by i2 or by the loop's length whichever is less. If
        // vectors are not assigned NULL prior the call, it is assumed
        // that they are properly (i1-offset, i2-i1+1 length) allocated.
        //   The return codes are same as those of GetLoopString(..),
        // GetLoopReal(..) and GetLoopInteger(..).
        int  GetLoopSVector ( psvector & S, cpstr CName,
                              cpstr TName, int i1=0, int i2=MaxInt4,
                              bool Remove=false );
        int  GetLoopRVector ( rvector  & R, cpstr CName,
                              cpstr TName, int i1=0, int i2=MaxInt4,
                              bool Remove=false );
        int  GetLoopIVector ( ivector  & I, cpstr CName,
                              cpstr TName, int i1=0, int i2=MaxInt4,
                              bool Remove=false );


        // -------- Storing data

        //   Unless the data are to be added to the existing CIF structure,
        // FreeMemory() should be called once before creating a new
        // CIF data set.
        void FreeMemory ( int key );

        void PutDataName ( cpstr dname ); // stores name for 'data_'
                                          // record

        //   PutString(..), PutReal(..) and PutInteger(..) will put the
        // values given into the specified category (CName) under the
        // specified tag (TName). The category, tag and field are created
        // automatically; the field will be replaced silently if identical
        // CName.TName is specified in two calls. Calls of these functions
        // may follow in random order; however CIF file will have all tags
        // grouped by categories and catgories will follow in the order
        // of first appearance in PutString(..), PutReal(..) or
        // PutInteger(..).
        //   Return code - one of CIFRC_Ok or CIFRC_NotAStruct
        int  PutNoData   ( int NoDataType, cpstr CName,
                           cpstr TName );
        int  PutString   ( cpstr S, cpstr CName,
                           cpstr TName, bool Concatenate=false );
        int  PutDate     ( cpstr CName, cpstr TName );
        int  PutReal     ( realtype R, cpstr CName, cpstr TName,
                                       int prec=8 );
        int  PutInteger  ( int I, cpstr CName, cpstr TName );

        //   If loop category CName is not present in the CIF data
        // structure, AddLoop(..) creates an empty one and returns
        // its pointer in Loop. If loop category CName is already in
        // the CIF data structure, its pointer is returned, and any
        // data which might be contained in it, remains untouched.
        //   To stuff the loop with data, first the data tags have to
        // be specified by calling  Loop->AddLoopTag(..). After all
        // tags are given, the data comes as a stream of calls
        // Loop->AddString(..), Loop->AddReal(..) and
        // Loop->AddInteger(..) which should provide data for every
        // tag in sequence in strictly the same order as the tags
        // were given. This essentially reflects reading a CIF loop
        // from a file.
        //   Alternatively, the loop data may be stored with PutLoopXXX()
        // functions given below, although this way may be less
        // efficient (but more flexible).
        //   AddLoop(..) may return
        //     CIFRC_Ok       category was present
        //     CIFRC_Created  category was not present but it has
        //                    been created; the category is empty
        //     CIFRC_NotALoop category was present as a structure, but
        //                    has been replaced for a loop;
        //                    the category is empty.
        int  AddLoop      ( cpstr CName, PLoop   & cifLoop   );
        int  AddStructure ( cpstr CName, PStruct & cifStruct );

        //   PutLoopString(..), PutLoopReal(..) and PutLoopInteger(..) act
        // like PutString(..), PutReal(..) and PutInteger(..) above for
        // nrow-th element of the 'loop_' CName (indexed begining from 0).
        // In consequitive calls, given values of nrow does not have to be
        // ordered; the most efficient way is to start with HIGHEST value
        // for nrow in the loop and move down to 0. The least efficient way
        // is to start with nrow=0 and move up.
        //   These functions allow to form loops in arbitrary way.
        //   The functions may return CIFRC_Ok or CIFRC_NotALoop.
        int  PutLoopNoData  ( int NoDataType, cpstr CName,
                                              cpstr TName, int nrow );
        int  PutLoopString  ( cpstr S,   cpstr CName,
                                              cpstr TName, int nrow );
        int  PutLoopReal    ( realtype R, cpstr CName,
                                          cpstr TName, int nrow,
                                          int  prec=8 );
        int  PutLoopInteger ( int I, cpstr CName, cpstr TName,
                                     int nrow );

        //   PutLoopSVector(..), PutLoopRVector(..) and PutLoopIVector(..)
        // put vectors of values into specified loop fields. Parameters i1
        // and i2 give the range of indices of values which are to be
        // transfered. To transfer an entire vector allocated as [0..N-1]
        // i1 shoudl be set to 0 and i2 - to N-1. Note that the loop is
        // always indexed as starting form 0 on, therefore negative i1 and
        // i2 are not allowed, and specifying i1>0 will leave first i1
        // elements of the CIF loop for the corresponding tag undefined
        // (will be output like '?').
        //   These functions allow to form loops in arbitrary way.
        int  PutLoopSVector ( psvector S, cpstr CName,
                              cpstr TName, int i1, int i2 );
        int  PutLoopRVector ( rvector  R, cpstr CName,
                              cpstr TName, int i1, int i2,
                              int prec=8 );
        int  PutLoopIVector ( ivector  I, cpstr CName,
                              cpstr TName, int i1, int i2 );

        int  RenameCategory ( cpstr CName, cpstr newCName );

        // --------

        void Copy         ( PData Data );
        int  CopyCategory ( PData Data, cpstr CName,
                                        cpstr newCName=NULL );

        void PrintCategories();  // for debuging only

        void write ( io::RFile f );
        void read  ( io::RFile f );

      protected:
        pstr       name;
        int        nCategories;
        PPCategory Category;
        ivector    index;
        int        flags;
        int        Warning;
        int        loopNo;  // used locally for suggesting categories
        int        tagNo;   // used locally for suggesting tags
        psvector   WrongCat;
        psvector   WrongTag;
        int        nWrongFields;

        void  InitData        ();
        void  FreeWrongFields ();
        bool  CheckWrongField ( cpstr C, cpstr T );
        void  Sort            ();

        //   GetCategoryNo searches for index of category cname
        // in Category[]. Return:
        //    >=0 : position of the category found
        //     <0 : the category was not found, it could be inserted before
        //          (-RC-1)th element, where RC is the return value
        int  GetCategoryNo  ( cpstr cname );
        int  AddCategory    ( cpstr cname );
        int  DeleteCategory ( int  CatNo );

        void GetDataItem    ( io::RFile f, pstr S, pstr & L, pstr & p,
                                        int & lcount, int & llen );
        void GetLoop        ( io::RFile f, pstr S, pstr & L, pstr & p,
                                        int & lcount, int & llen );
        int  GetField       ( io::RFile f, pstr S, pstr & L, pstr & p,
                                        int & lcount, int & llen );

    };



    //  ========================  File  =============================

    DefineClass(File);
    DefineStreamFunctions(File);

    class File : public io::Stream  {

      public :
        int      nData;
        ivector  index;
        PPData   data;

        File ();
        File ( cpstr FName, io::GZ_MODE gzipMode=io::GZM_CHECK );
        File ( io::RPStream Object );
        ~File();

        void  SetPrintWarnings ( bool SPW ) { PrintWarnings = SPW; }
        void  SetStopOnWarning ( bool SOW ) { StopOnWarning = SOW; }

        int   ReadMMCIFFile  ( cpstr FName,
                               io::GZ_MODE gzipMode=io::GZM_CHECK );
        int   WriteMMCIFFile ( cpstr FName,
                               io::GZ_MODE gzipMode=io::GZM_CHECK );

        int   GetNofData()  { return nData; }
        PData GetCIFData     ( int   dataNo );  // 0..nData-1
        PData GetCIFData     ( cpstr DName  );
        int   AddCIFData     ( cpstr DName  );
        int   DeleteCIFData  ( cpstr DName  );
        int   DeleteCIFData  ( int   dataNo );
        int   GetCIFDataNo   ( cpstr DName  );

        void  WriteMMCIF     ( io::RFile f  );

        void  Copy  ( PFile File );

        void  write ( io::RFile f );
        void  read  ( io::RFile f );

      protected:
        int  nAllocData;
        bool PrintWarnings;
        bool StopOnWarning;

        void  InitFile   ();
        void  FreeMemory ();
        void  Sort       ();
        void  ExpandData ( int nDataNew );

    };


    extern pstr GetMMCIFInputBuffer ( int & LineNo );

    //  isCIF will return
    //    -1   if file FName does not exist
    //     0   if file FName is likely a CIF file ( 'data_' is present )
    //     1   if file FName is not a CIF file ( 'data_' is absent )
    extern int isCIF ( cpstr FName, io::GZ_MODE gzipMode=io::GZM_CHECK );
    extern int isCIF ( io::RFile f );

    pstr GetCIFMessage ( pstr M, int RC );


  }  // namespace mmcif

}  // namespace mmdb


#endif