ofstd/include/dcmtk/ofstd/ofconfig.h

/*
 *
 *  Copyright (C) 1997-2010, OFFIS e.V.
 *  All rights reserved.  See COPYRIGHT file for details.
 *
 *  This software and supporting documentation were developed by
 *
 *    OFFIS e.V.
 *    R&D Division Health
 *    Escherweg 2
 *    D-26121 Oldenburg, Germany
 *
 *
 *  Module:  ofstd
 *
 *  Author: Marco Eichelberg
 *
 *  Purpose:
 *    classes: OFConfigFile
 *
 *  Last Update:      $Author: joergr $
 *  Update Date:      $Date: 2010-10-14 13:15:50 $
 *  CVS/RCS Revision: $Revision: 1.8 $
 *  Status:           $State: Exp $
 *
 *  CVS/RCS Log at end of file
 *
 */

#ifndef OFCONFIG_H
#define OFCONFIG_H

#include "dcmtk/config/osconfig.h"    /* make sure OS specific configuration is included first */
#include "dcmtk/ofstd/ofstring.h"
#include "dcmtk/ofstd/ofstack.h"
#include "dcmtk/ofstd/ofstream.h"

#define INCLUDE_CSTDIO
#include "dcmtk/ofstd/ofstdinc.h"

/*
 *  Short description of configuration file structure:
 *    - The data in a configuration file have a tree structure.
 *      The tree has a depth defined at instantiation time (by default, OFConfigFile_MaxLevel), 
 *      not including the (imaginary) root node.
 *    - A level 0 entry (a leaf) has the form: KEYWORD = VALUE,
 *      where the keyword starts on row one of a line.
 *    - A level 1 entry has the form [KEYWORD]
 *    - A level 2 entry has the form [[KEYWORD]] (and so on).
 *    - Keywords may consist of:
 *        A..Z, a..z (which are converted to uppercase),
 *        0..9,
 *        '-'
 *    - Values can be any kind of ASCII text. Values may span multiple lines.
 *      To continue a value in the next line, the next line MUST start with
 *      (any amount of) whitespace, which is discarded when reading the value.
 *      linefeeds (converted to ASCII 10 if necessary) are kept in the
 *      value string. Empty lines are discarded (and also their linefeed).
 *    - The data must have a "clean" tree structure. This means that there
 *      MUST be a level 2 keyword before any level 1 keyword etc.
 *    - lines starting with the comment char (default  is "#") are interpreted 
 *      as comment lines.
 *
 */

#define OFConfigFile_MaxLevel 2
#define OFConfigFile_CommentChar '#'

class OFConfigFile;
class OFConfigFileNode;

typedef OFConfigFileNode *OFPConfigFileNode;


class OFConfigFileNode
{
public:
  OFConfigFileNode(const char *keyword);

  ~OFConfigFileNode();

  const char *getKeyword() const
  {
    return keyword_.c_str();
  }

  const char *getValue() const
  {
    return value_.c_str();
  }

  void setValue(const char *c)
  {
    value_ = c;
  }

  OFBool match(const char *c) const
  {
    return (keyword_ == c);
  }

  OFBool less(const char *c) const
  {
    return (keyword_ < c);
  }

  OFConfigFileNode *getBrother() const
  {
    return brother_;
  }

  OFConfigFileNode *getSon() const
  {
    return son_;
  }

  void setBrother(OFConfigFileNode *brother)
  {
    brother_ = brother;
  }

  void setSon(OFConfigFileNode *son)
  {
    son_ = son;
  }

  void print(STD_NAMESPACE ostream& out, unsigned int level);

private:
  OFConfigFileNode(const OFConfigFileNode& arg);

  OFConfigFileNode &operator=(const OFConfigFileNode& arg);

  OFConfigFileNode *brother_;

  OFConfigFileNode *son_;

  OFString keyword_;

  OFString value_;
};

typedef OFConfigFileNode *OFConfigFileNodePtr;

class OFConfigFileCursor
{
public:
  OFConfigFileCursor(unsigned int maxLevel) 
  : array_(NULL)
  , maxLevel_(maxLevel)
  { 
    clear(); 
  }

  OFConfigFileCursor(const OFConfigFileCursor& source);

  ~OFConfigFileCursor() 
  {
    delete[] array_;
  }

  OFConfigFileCursor& operator=(const OFConfigFileCursor& source);

  void clear();

  const char *getKeyword(unsigned int level) const
  {
    if ((level <= maxLevel_) && array_ && array_[level]) return array_[level]->getKeyword(); else return NULL;
  }

  const char *getValue(unsigned int level) const
  {
    if ((level <= maxLevel_) && array_ && array_[level]) return array_[level]->getValue(); else return NULL;
  }

  OFBool section_valid(unsigned int level) const;

  void set_section(
    unsigned int level, 
    const char *key,
    OFConfigFileNode *anchor);
   
  void first_section(
    unsigned int level,
    OFConfigFileNode *anchor);

  void next_section(unsigned int level);

  void insert(
    unsigned int level,
    OFConfigFileNode *& newnode,
    OFConfigFileNode *& anchor,
    OFBool orderedMode);

  OFBool operator<(const OFConfigFileCursor& /* arg */) const
  {
    return OFFalse;
  }

  OFBool operator==(const OFConfigFileCursor& /* arg */) const
  {
    return OFTrue;
  }

private:

  void orderedInsert(
    OFConfigFileNode *parent,
    OFConfigFileNode *&newnode);

  OFConfigFileNodePtr *array_;

  unsigned int maxLevel_;  
};


class OFConfigFile
{
public:

  OFConfigFile(
    FILE *infile, 
    unsigned int maxLevel = OFConfigFile_MaxLevel,
    char commentChar = OFConfigFile_CommentChar,
    OFBool orderedMode = OFFalse);

  virtual ~OFConfigFile();

  void loadFile(FILE *infile);
  
  const char *get_keyword(unsigned int level);
  
  const char *get_value();
  
  OFBool get_bool_value(OFBool defaultvalue);
  
  OFBool section_valid(unsigned int level) const
  {
    return cursor_.section_valid(level);
  }
  
  void set_section(unsigned int level, const char *key)
  {
    cursor_.set_section(level, key, anchor_);
  }
   
  void first_section(unsigned int level)
  {
    cursor_.first_section(level, anchor_);
  }

  void next_section(unsigned int level)
  {
    cursor_.next_section(level);
  }
  
  void save_cursor();
  
  void restore_cursor();
  
  void select_section(
    const char *key1,
    const char *key2=NULL,
    const char *key3=NULL);
  
  const char *get_entry(const char *key0);

  void print(STD_NAMESPACE ostream& out);

private:  

  char read_char(FILE *infile);

  char read_keywordchar(FILE *infile);
  
  void read_entry(FILE *infile);
  
  void store_char(char c);

  OFConfigFile(const OFConfigFile&);
  
  OFConfigFile& operator=(const OFConfigFile&);


  OFStack<OFConfigFileCursor> stack_;

  OFConfigFileCursor cursor_;

  OFConfigFileNode *anchor_;

  int isnewline_;

  int crfound_;

  char *buffer_;

  size_t bufptr_;

  long bufsize_;

  unsigned int maxLevel_;  

  char commentChar_;
  
  OFBool orderedMode_;
};

#endif

/*
 *  $Log: ofconfig.h,v $
 *  Revision 1.8  2010-10-14 13:15:50  joergr
 *  Updated copyright header. Added reference to COPYRIGHT file.
 *
 *  Revision 1.7  2010-04-26 12:22:30  uli
 *  Fixed a some minor doxygen warnings.
 *
 *  Revision 1.6  2008-04-16 09:37:27  meichel
 *  class OFConfigFile now supports an ordered mode where multiple
 *    configuration files can be loaded and can replace entries of other.
 *    Also added function to print content of configuration in reloadable format.
 *
 *  Revision 1.5  2008-04-15 15:46:30  meichel
 *  class OFConfigFile now supports flexible tree depths and configurable
 *    comment characters and can, therefore, fully replace the equivalent
 *    code in module dcmprint.
 *
 *  Revision 1.4  2005/12/08 16:05:51  meichel
 *  Changed include path schema for all DCMTK header files
 *
 *  Revision 1.3  2003/06/12 13:15:59  joergr
 *  Fixed inconsistent API documentation reported by Doxygen.
 *
 *  Revision 1.2  2003/06/04 12:31:44  meichel
 *  Added dummy comparison operators, needed by MSVC5 with STL
 *
 *  Revision 1.1  2003/04/29 10:14:16  meichel
 *  Moved configuration file parser from module dcmpstat to ofstd and renamed
 *    class to OFConfigFile. Cleaned up implementation (no more friend declarations).
 *
 *
 */

---

Generated on 6 Jan 2011 for OFFIS DCMTK Version 3.6.0 by Doxygen 1.5.1