source: trunk/gsdl/src/recpt/cgiargs.cpp@ 411

/**********************************************************************
 *
 * cgiargs.cpp -- 
 * Copyright (C) 1999  The New Zealand Digital Library Project
 *
 * PUT COPYRIGHT NOTICE HERE
 *
 * $Id: cgiargs.cpp 364 1999-07-11 01:02:13Z rjmcnab $
 *
 *********************************************************************/

/*
   $Log$
   Revision 1.6  1999/07/11 01:02:13  rjmcnab
   Stored information relating to the cgi argument's origin with the cgi argument.

   Revision 1.5  1999/02/08 01:28:00  rjmcnab

   Got the receptionist producing something using the statusaction.

   Revision 1.4  1999/02/05 10:42:41  rjmcnab

   Continued working on receptionist

   Revision 1.3  1999/02/04 10:00:54  rjmcnab

   Developed the idea of an "action" and having them define the cgi arguments
   which they need and how those cgi arguments function.

   Revision 1.2  1999/01/12 01:51:06  rjmcnab

   Standard header.

   Revision 1.1  1999/01/08 08:40:54  rjmcnab

   Moved from lib directory.

   Revision 1.1  1999/01/08 07:50:30  rjmcnab

   Moved from src/library directory to lib directory.

 */


#include "cgiargs.h"
#include "gsdlunicode.h"



void cgiarg_t::clear () {
  value.clear();
  source = program_arg;
}

cgiarg_t &cgiarg_t::operator=(const cgiarg_t &x) {
  value=x.value;
  source=x.source;
  return *this;
}




// constructors
cgiargsclass::cgiargsclass () {
}


// this returns NULL if there isn't an entry with a value of
// 'key' already defined

void cgiargsclass::setarg (const text_t &key, const text_t &value,
               cgiarg_t::source_t source) {
  cgiarg_t temparg;
  temparg.value = value;
  temparg.source = source;
  args[key] = temparg;
}

void cgiargsclass::setdefaultarg (const text_t &key, const text_t &value,
                  cgiarg_t::source_t source) {
  if (getarg(key) == NULL) setarg (key, value, source);
}

void cgiargsclass::setintarg (const text_t &key, int value,
                  cgiarg_t::source_t source) {
  setarg (key, value, source);
}

void cgiargsclass::setdefaultintarg (const text_t &key, int value,
                     cgiarg_t::source_t source) {
  if (getarg(key) == NULL) setintarg (key, value, source);
}

void cgiargsclass::setcarg (const text_t &key, unsigned short c,
                cgiarg_t::source_t source) {
  text_t t; 
  t.push_back(c);
  setarg(key,t, source);
}

void cgiargsclass::setdefaultcarg (const text_t &key, unsigned short c,
                   cgiarg_t::source_t source) {
  if (getarg(key) == NULL) setcarg (key, c, source);
}

text_t *cgiargsclass::getarg (const text_t &key) {
  iterator here = args.find (key);
  if (here == args.end()) return NULL;

  return &((*here).second.value);
}

int cgiargsclass::getintarg (const text_t &key) {
  text_t *text = getarg (key);
  if (text == NULL) return 0;
  return text->getint();
}



// stream operators to print cgi arguments for debugging purposes
ostream &operator<<(ostream &outs, const cgiargsclass &args) {
  utf8outconvertclass text_t2utf8;
  cgiargsclass::const_iterator here = args.begin ();
  cgiargsclass::const_iterator end = args.end ();

  outs << "*** cgiargsclass\n";
  
  while (here != end) {
    outs << text_t2utf8 << " \"" << (*here).first << "\"=\"" << 
      (*here).second.value << "\"\n";
    here++;
  }
  outs << "\n";

  return outs;
}



cgiarginfo::cgiarginfo () {
  multiplechar = false;
  defaultstatus = weak;
}

  
// constructor
cgiargsinfoclass::cgiargsinfoclass () {
}

// addarginfo will combine the information with the present
// information. If name clashes were detected then the information
// will be written to logout and addarginfo will return false. No
// processing with the arguments should be done if this happens
// as the results will be meaningless.
bool cgiargsinfoclass::addarginfo (ostream *logout, const cgiarginfo &info) {
  outconvertclass text_t2ascii;

  cgiarginfo *orginfo = getarginfo (info.shortname);
  if (orginfo == NULL) {
    argsinfo[info.shortname] = info;
    return true; // no clashes
  }

  if (orginfo->longname != info.longname) {
    if (logout != NULL) {
      (*logout) << text_t2ascii << "Error: cgi argument name clash for argument \""
        << info.shortname << "\".\nOne long name was\n  \"" << orginfo->longname 
        << "\"\nand the other was\n  \"" << info.longname << "\".\n\n";
    }
    return false; // found a clash
  }

  if (orginfo->multiplechar != info.multiplechar) {
    if (logout != NULL) {
      (*logout) << text_t2ascii << "Error: cgi argument \"" << info.shortname 
        << "\" was given as being a single character option\n"
        << "and a multiple character option.\n\n";
    }
    return false; // found a clash
  }
  
  if (!info.multiplechar && info.argdefault.size() > 1) {
    if (logout != NULL) {
      (*logout) << text_t2ascii << "Error: cgi argument \"" << info.shortname
        << "\" was defined as being a single character option\n"
        << "but a multiple character default was given.\n\n";
    }
    return false;  // found a problem
  }

  // make sure there is no clashes in the savedarginfo
  if ((orginfo->savedarginfo==cgiarginfo::mustnot && 
       info.savedarginfo==cgiarginfo::must) ||
      (orginfo->savedarginfo==cgiarginfo::must && 
       info.savedarginfo==cgiarginfo::mustnot)) {
    if (logout != NULL) {
      (*logout) << text_t2ascii << "Error: it was specified that cgi argument \"" 
        << info.shortname << "\" should be saved in the state\n"
        << "information and that it should not be save in the state information.\n\n";
    }
    return false; // found a clash
  }
  // the only time orginfo->savedarginfo can change is when it is set
  // to "can"
  if (orginfo->savedarginfo == cgiarginfo::can) 
    orginfo->savedarginfo = info.savedarginfo;


  if (orginfo->defaultstatus > info.defaultstatus) {
    return true;
  }
  orginfo->defaultstatus = info.defaultstatus;
  orginfo->argdefault = info.argdefault;

  return true;
}

bool cgiargsinfoclass::addarginfo (ostream *logout, const cgiargsinfoclass &info) {
  const_iterator here = info.begin ();
  const_iterator end = info.end ();

  while (here != end) {
    if (!addarginfo (logout, (*here).second)) return false;
    here++;
  }
  
  return true; // made it, no clashes
}

cgiarginfo *cgiargsinfoclass::getarginfo (const text_t &key) {
  iterator here = argsinfo.find (key);
  if (here == argsinfo.end()) return NULL;

  return &((*here).second);
}

const cgiarginfo *cgiargsinfoclass::getarginfo (const text_t &key) const {
  const_iterator here = argsinfo.find (key);
  if (here == argsinfo.end()) return NULL;

  return &((*here).second);
}