CIFFile.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_FORMAT_CIFFILE_H
#define BALL_FORMAT_CIFFILE_H

#ifndef BALL_SYSTEM_FILE_H
# include <BALL/SYSTEM/file.h>
#endif

#ifndef BALL_DATATYPE_STRINGHASHMAP_H
# include <BALL/DATATYPE/stringHashMap.h>
#endif

#ifndef BALL_KERNEL_MOLECULE_H
# include <BALL/KERNEL/molecule.h>
#endif

#include <map>

#define CIFPARSER_LINE_LENGTH 2550

namespace BALL
{
  class BALL_EXPORT CIFFile
    : public File
  {
    public:
  
      class Item
      {
        public:

          Item();
          
          Item(const Item& item);

          virtual ~Item();

          void clear();
          void addPair(String key, String value);
          void startLoop();
          void addTag(String tag);
          void addValue(String value);
        
          Index getKeyIndex(String key);
          
          /* a data item may be a tag-value pair or a table */
          bool is_loop;

          //StringHashMap< Index > data;
          std::vector<String> keys;
          std::vector<std::vector<String> > values;

          std::pair<String, String> entry;
          
          std::ostream& operator >> (std::ostream& os) const;

      };
      
      class SaveFrame
      {
        public:
          
          void clear();
          void start(String name); 
          void addDataItem(Item item);
          void setCategory(String cat) {category = cat;};
          
          std::ostream& operator >> (std::ostream& os) const;
          const String& getCategory() const {return category;};
          
          const Item&  getDataItem(const String& item_name) const;
          // we allow manipulation
          Item&  getDataItem(const String& item_name);

          const String& getDataItemValue(const String& item_name) const;
          // we allow manipulation
          String&  getDataItemValue(const String& item_name);



          bool hasItem (const String& item_name) const;
          String getItemValue(const String& name) const;

          
          String framename; 
          String category; // always first_item.entry.second

          std::vector<Item> items; 
          StringHashMap<Index> pair_items;
          
          Item dummy_data_item_; 

      };

      class Datacontent
      {
        public:
          
          Datacontent();
          Datacontent(SaveFrame new_saveframe);
          Datacontent(Item new_item);

          bool is_saveframe;
    
          SaveFrame saveframe;

          Item dataitem;

          std::ostream& operator >> (std::ostream& os) const;

      };
      
      class Datablock
      {
        public:
          void clear();
          
          void start(String blockname);

          void insertDatacontent(const Datacontent& content);
          void insertDatacontent(const SaveFrame& new_saveframe);
          void insertDatacontent(const Item& item);

          const Item&  getDataItem(const String& item_name) const;
          Item&  getDataItem(const String& item_name);
          
          const std::vector<Index> getSaveframeIndicesByCategory(const String& name) const;
          std::vector<Index> getSaveframeIndicesByCategory(const String& name);
          /* Returns copies of saveframes of category name */
          std::vector<SaveFrame> getSaveframesByCategory(const String& name) const;

          
          const SaveFrame& getSaveframeByName(const String& name) const;
          SaveFrame& getSaveframeByName(const String& name);
      
          const SaveFrame& getSaveframeByIndex(const Index index) const;
          SaveFrame& getSaveframeByIndex(const Index index);


          // 
          bool hasSaveframeName(const String& name) const;
          bool hasSaveframeCategory(const String& name) const;
          bool hasItem(const String& name) const;

          void setName(String blockname);

          std::ostream& operator >> (std::ostream& os) const;

          String name;

          std::vector<Datacontent> data;
          
          StringHashMap<Index> saveframe_names;
          //StringHashMap<std::vector<Index> > saveframe_categories;
          std::multimap<String, Index> saveframe_categories;

          StringHashMap<Index> item_names; 

          Item dummy_data_item_; 
          SaveFrame dummy_saveframe_; 
          vector<SaveFrame> dummy_saveframes_; 
          vector<Index> dummy_indices_; 

      };

      struct State
      {
        CIFFile* current_parser;
      };
      
      
      CIFFile();

      CIFFile(const String& filename, File::OpenMode open_mode = std::ios::in)
        throw(Exception::FileNotFound);

      virtual ~CIFFile();
      

      
      virtual bool write()
        throw(File::CannotWrite);

      virtual bool read()
        throw(Exception::ParseError);
      

      void inSafeframe(const char* name);
      
      void inItem(const char* name);
      
      void inDatablock(const char* name);

      void insertDatablock(const Datablock& datablock);
      
      const Datablock& getDatablock(const String& name) const;

    
      // we allow manipulation :-)
      Datablock& getDatablock(const String& name); 

      bool hasDatablock(const String& name) const;

      void setMolecule(Molecule* molecule);
    
      void clearParameters();

      static State state;

    protected:
      virtual void initRead_();

      Molecule* molecule_;
      
      String current_datablock_;
      String current_saveframe_;
      String current_item_;
      
      StringHashMap<Index> datablocks_hash_;
      vector<Datablock> datablocks_;
  };  
}
#endif // BALL_FORMAT_CIFFILE_H

---