---

keyval.h

//
// keyval.h
//
// Copyright (C) 1996 Limit Point Systems, Inc.
//
// Author: Curtis Janssen <cljanss@limitpt.com>
// Maintainer: LPS
//
// This file is part of the SC Toolkit.
//
// The SC Toolkit is free software; you can redistribute it and/or modify
// it under the terms of the GNU Library General Public License as published by
// the Free Software Foundation; either version 2, or (at your option)
// any later version.
//
// The SC Toolkit 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 Library General Public License for more details.
//
// You should have received a copy of the GNU Library General Public License
// along with the SC Toolkit; see the file COPYING.LIB.  If not, write to
// the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
//
// The U.S. Government is granted a limited license as per AL 91-7.
//

#ifndef _util_keyval_keyval_h
#define _util_keyval_keyval_h
#ifdef __GNUG__
#pragma interface
#endif

#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>

#include <util/container/avlmap.h>
#include <util/class/class.h>
#include <util/keyval/keyvalval.h>

class KeyValKeyword {
  private:
    char* keyword_;
  public:
    KeyValKeyword();
    KeyValKeyword(const char* name);
    KeyValKeyword(const KeyValKeyword&);
    ~KeyValKeyword();
    KeyValKeyword& operator=(const KeyValKeyword&);
    int operator==(const KeyValKeyword& ck) const;
    int operator<(const KeyValKeyword& ck) const;
    int hash() const;
    inline int cmp(const KeyValKeyword&ck) const
    {
      if (!keyword_) {
          if (!ck.keyword_) return 0;
          return -1;
        }
      if (!ck.keyword_) return 1;
      return strcmp(keyword_,ck.keyword_);
    }
    inline const char* name() const {return keyword_;}
  };

class KeyVal: public RefCount {
    // these classes need to directly access the key_value member
    friend class AggregateKeyVal;
    friend class PrefixKeyVal;
  public:
    enum {MaxKeywordLength = 256};
    enum KeyValError { OK, HasNoValue, WrongType,
                       UnknownKeyword, OperationFailed };
  private:
    KeyValError errcod;
    // do not allow a copy constructor or assignment
    KeyVal(const KeyVal&);
    void operator=(const KeyVal&);
  protected:
    int verbose_;

    KeyVal();

    void seterror(KeyValError err);
    void seterror(KeyValValue::KeyValValueError err);

    virtual int    key_exists(const char*) = 0;
    virtual int    key_count(const char* =0);
    virtual Ref<KeyValValue> key_value(const char*,
                                     const KeyValValue& def) = 0;
    virtual int    key_booleanvalue(const char*,const KeyValValue& def);
    virtual double key_doublevalue(const char* key,const KeyValValue& def);
    virtual float  key_floatvalue(const char* key,const KeyValValue& def);
    virtual char   key_charvalue(const char* key,const KeyValValue& def);
    virtual int    key_intvalue(const char* key,const KeyValValue& def);
    virtual char*  key_pcharvalue(const char* key,const KeyValValue& def);
    virtual Ref<DescribedClass> key_describedclassvalue(const char* key,
                                                      const KeyValValue& def);

  public:
    virtual ~KeyVal();

    // For nonindexed things.   If a subclass defines one of these,
    // then the overloaded functions will be hidden.  The key_... functions
    // should be overridden instead.

    int    exists(const char*);
    int    count(const char* =0);
    Ref<KeyValValue> value(const char* = 0,
                         const KeyValValue& def=KeyValValue());
    int    booleanvalue(const char* key = 0,
                        const KeyValValue& def=KeyValValueboolean());
    double doublevalue(const char* key = 0,
                       const KeyValValue& def=KeyValValuedouble());
    float  floatvalue(const char* key = 0,
                      const KeyValValue& def=KeyValValuefloat());
    char   charvalue(const char* key = 0,
                     const KeyValValue& def=KeyValValuechar());
    int    intvalue(const char* key = 0,
                    const KeyValValue& def=KeyValValueint());
    char*  pcharvalue(const char* key = 0,
                      const KeyValValue& def=KeyValValuepchar());
    Ref<DescribedClass> describedclassvalue(const char* key = 0,
                     const KeyValValue& def=KeyValValueRefDescribedClass());

    // For vectors:
    int    exists(const char*,int);
    int    count(const char*,int);
    int    booleanvalue(const char*,int,
                        const KeyValValue& def=KeyValValueboolean());
    double doublevalue(const char* key,int,
                       const KeyValValue& def=KeyValValuedouble());
    float  floatvalue(const char* key,int,
                      const KeyValValue& def=KeyValValuefloat());
    char   charvalue(const char* key,int,
                     const KeyValValue& def=KeyValValuechar());
    int    intvalue(const char* key,int,
                    const KeyValValue& def=KeyValValueint());
    char*  pcharvalue(const char* key,int,
                      const KeyValValue& def=KeyValValuepchar());
    Ref<DescribedClass> describedclassvalue(const char* key,int,
                     const KeyValValue& def=KeyValValueRefDescribedClass());

    int    exists(int i);
    int    count(int i);
    int    booleanvalue(int i,
                        const KeyValValue& def=KeyValValueboolean());
    double doublevalue(int i,
                       const KeyValValue& def=KeyValValuedouble());
    float  floatvalue(int i,
                      const KeyValValue& def=KeyValValuefloat());
    char   charvalue(int i,
                     const KeyValValue& def=KeyValValuechar());
    int    intvalue(int i,
                    const KeyValValue& def=KeyValValueint());
    char*  pcharvalue(int i,
                      const KeyValValue& def=KeyValValuepchar());
    Ref<DescribedClass> describedclassvalue(int i,
                     const KeyValValue& def=KeyValValueRefDescribedClass());

    // For arrays:
    int    exists(const char*,int,int);
    int    count(const char*,int,int);
    int    booleanvalue(const char*,int,int,
                        const KeyValValue& def=KeyValValueboolean());
    double doublevalue(const char* key,int,int,
                       const KeyValValue& def=KeyValValuedouble());
    float  floatvalue(const char* key,int,int,
                      const KeyValValue& def=KeyValValuefloat());
    char   charvalue(const char* key,int,int,
                     const KeyValValue& def=KeyValValuechar());
    int    intvalue(const char* key,int,int,
                    const KeyValValue& def=KeyValValueint());
    char*  pcharvalue(const char* key,int,int,
                      const KeyValValue& def=KeyValValuepchar());
    Ref<DescribedClass> describedclassvalue(const char* key,int,int,
                     const KeyValValue& def=KeyValValueRefDescribedClass());

    int    exists(int i,int j);
    int    count(int i,int j);
    int    booleanvalue(int i,int j,
                        const KeyValValue& def=KeyValValueboolean());
    double doublevalue(int i,int j,
                       const KeyValValue& def=KeyValValuedouble());
    float  floatvalue(int i,int j,
                      const KeyValValue& def=KeyValValuefloat());
    char   charvalue(int i,int j,
                     const KeyValValue& def=KeyValValuechar());
    int    intvalue(int i,int j,
                    const KeyValValue& def=KeyValValueint());
    char*  pcharvalue(int i,int j,
                      const KeyValValue& def=KeyValValuepchar());
    Ref<DescribedClass> describedclassvalue(int i,int j,
                     const KeyValValue& def=KeyValValueRefDescribedClass());

    // For all else:
    int    Va_exists(const char*,int,...);
    int    Va_count(const char*,int,...);
    int    Va_booleanvalue(const char*,int,...);
    double Va_doublevalue(const char* key,int,...);
    float  Va_floatvalue(const char* key,int,...);
    char   Va_charvalue(const char* key,int,...);
    int    Va_intvalue(const char* key,int,...);
    char*  Va_pcharvalue(const char* key,int,...);
    Ref<DescribedClass> Va_describedclassvalue(const char* key,int,...);

    KeyValError error();
    const char*  errormsg(KeyValError err);
    const char*  errormsg();

    virtual void errortrace(std::ostream&fp=ExEnv::err());
    virtual void dump(std::ostream&fp=ExEnv::err());

    virtual void print_unseen(std::ostream&fp=ExEnv::out());
    virtual int have_unseen();

    void verbose(int v) { verbose_ = v; }
    int verbose() const { return verbose_; }
};



// this class allows keyval associations to be set up by the program,
// rather than determined by an external file
class AssignedKeyVal: public KeyVal {
  private:
    AVLMap<KeyValKeyword,Ref<KeyValValue> > _map;
    // do not allow a copy constructor or assignment
    AssignedKeyVal(const AssignedKeyVal&);
    void operator=(const AssignedKeyVal&);
  protected:
    int    key_exists(const char*);
    Ref<KeyValValue> key_value(const char*,
                             const KeyValValue& def);
  public:
    AssignedKeyVal();
    ~AssignedKeyVal();

    void assign(const char*, const Ref<KeyValValue>&);
    void assign(const char*, double);
    void assignboolean(const char*, int);
    void assign(const char*, float);
    void assign(const char*, char);
    void assign(const char*, int);
    void assign(const char*, const char*);
    void assign(const char*, const Ref<DescribedClass>&);

    void clear();
};



class StringKeyVal: public KeyVal {
  private:
    // once a described class is found it is kept here so
    // multiple references to it return the same instance
    AVLMap<KeyValKeyword,Ref<KeyValValue> > _map;
    // do not allow a copy constructor or assignment
    StringKeyVal(const StringKeyVal&);
    void operator=(const StringKeyVal&);
  protected:
    StringKeyVal();
    int    key_exists(const char*);
    Ref<KeyValValue> key_value(const char*,
                             const KeyValValue& def);
  public:
    virtual ~StringKeyVal();
    virtual const char* stringvalue(const char *) = 0;
    // returns the name of the exact class the object at the keyword
    virtual const char* classname(const char*);
    // returns a string which is the actual keyword if some sort
    // of variable substitution takes place (needed to make multiple
    // references to the same object work in input files)
    virtual const char* truekeyword(const char*);

    virtual void errortrace(std::ostream&fp=ExEnv::err());
    virtual void dump(std::ostream&fp=ExEnv::err());
};

class AggregateKeyVal : public KeyVal {
  private:
    enum { MaxKeyVal = 4 };
    Ref<KeyVal> kv[MaxKeyVal];
    Ref<KeyVal> getkeyval(const char*key);
    // do not allow a copy constructor or assignment
    AggregateKeyVal(const AggregateKeyVal&);
    void operator=(const AggregateKeyVal&);
  protected:
    int    key_exists(const char*);
    Ref<KeyValValue> key_value(const char*,
                             const KeyValValue& def);
  public:
    AggregateKeyVal(const Ref<KeyVal>&);
    AggregateKeyVal(const Ref<KeyVal>&,const Ref<KeyVal>&);
    AggregateKeyVal(const Ref<KeyVal>&,const Ref<KeyVal>&,const Ref<KeyVal>&);
    AggregateKeyVal(const Ref<KeyVal>&,const Ref<KeyVal>&,const Ref<KeyVal>&,
                    const Ref<KeyVal>&);
    ~AggregateKeyVal();
    void errortrace(std::ostream&fp=ExEnv::err());
    void dump(std::ostream&fp=ExEnv::err());
};

class PrefixKeyVal : public KeyVal {
  private:
    char* prefix;
    Ref<KeyVal> keyval;
    void setup(const char*,int,int,int,int,int);
    int getnewprefixkey(const char*key,char*newkey);
    // do not allow a copy constructor or assignment
    PrefixKeyVal(const PrefixKeyVal&);
    void operator=(const PrefixKeyVal&);
    int    key_exists(const char*);
    Ref<KeyValValue> key_value(const char*,
                             const KeyValValue& def);
  public:
    PrefixKeyVal(const Ref<KeyVal>&,int);
    PrefixKeyVal(const Ref<KeyVal>&,int,int);
    PrefixKeyVal(const Ref<KeyVal>&,int,int,int);
    PrefixKeyVal(const Ref<KeyVal>&,int,int,int,int);
    PrefixKeyVal(const Ref<KeyVal>&,const char*);
    PrefixKeyVal(const Ref<KeyVal>&,const char*,int);
    PrefixKeyVal(const Ref<KeyVal>&,const char*,int,int);
    PrefixKeyVal(const Ref<KeyVal>&,const char*,int,int,int);
    PrefixKeyVal(const Ref<KeyVal>&,const char*,int,int,int,int);
    // old CTOR syntax (use the above instead)
    PrefixKeyVal(const char*,const Ref<KeyVal>&);
    PrefixKeyVal(const char*,const Ref<KeyVal>&,int);
    PrefixKeyVal(const char*,const Ref<KeyVal>&,int,int);
    PrefixKeyVal(const char*,const Ref<KeyVal>&,int,int,int);
    PrefixKeyVal(const char*,const Ref<KeyVal>&,int,int,int,int);
    ~PrefixKeyVal();
    void errortrace(std::ostream&fp=ExEnv::err());
    void dump(std::ostream&fp=ExEnv::err());
};

class IPV2;
class ParsedKeyVal : public StringKeyVal {
  private:
    int nfile;
    char**file;
    int nfp;
    IPV2* ipv2;
    // do not allow a copy constructor or assignment
    ParsedKeyVal(const ParsedKeyVal&);
    void operator=(const ParsedKeyVal&);
  public:
    ParsedKeyVal();
    ParsedKeyVal(const char*file);
    ParsedKeyVal(std::istream&s);
    ParsedKeyVal(IPV2*);
    ParsedKeyVal(const char*,const Ref<KeyVal>&);
    ~ParsedKeyVal();

    static void cat_files(const char*,const Ref<KeyVal>&,std::ostream &o);

    void read(const char*);
    void read(std::istream&);
    void parse_string(const char *);

    // Overrides of parent members.
    const char* stringvalue(const char*);
    const char* classname(const char*);
    const char* truekeyword(const char*);
    void errortrace(std::ostream&fp=ExEnv::err());
    void dump(std::ostream&fp=ExEnv::err());
    void print_unseen(std::ostream&fp=ExEnv::out());
    int have_unseen();
};



#endif /* _KeyVal_h */

// Local Variables:
// mode: c++
// c-file-style: "CLJ"
// End:

---