deb-goldedplus/goldlib/gall/gusrbase.cpp

//  This may look like C code, but it is really -*- C++ -*-

//  ------------------------------------------------------------------
//  The Goldware Library
//  Copyright (C) 1990-1999 Odinn Sorensen
//  ------------------------------------------------------------------
//  This library 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 of the License, or (at your option) any later version.
//
//  This library 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 this program; if not, write to the Free
//  Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
//  MA 02111-1307, USA
//  ------------------------------------------------------------------
//  $Id$
//  ------------------------------------------------------------------
//  Userfile base class implementation.
//  ------------------------------------------------------------------

#include <gfilutil.h>
#include <gstrall.h>
#include <gwildmat.h>
#include <gusrbase.h>


//  ------------------------------------------------------------------

GUser::GUser() {

  fh      = -1;
  found   = false;
  index   = 0;
  name    = NULL;
  recno   = 0;
  records = 0;
  recptr  = NULL;
  recsize = 0;
}


//  ------------------------------------------------------------------

GUser::~GUser() {

  // No action
}


//  ------------------------------------------------------------------

void GUser::founduser() {

  index = recno;
  found = true;
}


//  ------------------------------------------------------------------

void GUser::inctimesposted(int) {

  // No action
}


//  ------------------------------------------------------------------

uint32_t GUser::lastread() {

  // No action
  return 0;
}


//  ------------------------------------------------------------------

void GUser::lastread(uint32_t) {

  // No action
}


//  ------------------------------------------------------------------

void GUser::recinit(const char* __name) {
  
  memset(recptr, 0, recsize);
  strcpy(name, __name);
}


//  ------------------------------------------------------------------

int GUser::moveto(uint __rec) {

  if(fh != -1) {
    if(__rec <= records) {
      lseek(fh, (long)__rec*(long)recsize, SEEK_SET);
      recno = __rec;
      return true;
    }
  }
  recno = records;
  return false;
}


//  ------------------------------------------------------------------

int GUser::next() {

  return moveto(++recno);
}


//  ------------------------------------------------------------------

int GUser::prev() {
                      
  return moveto(--recno);
}


//  ------------------------------------------------------------------

void GUser::seekread() {

  if(fh != -1) {
    lseek(fh, (long)recno*(long)recsize, SEEK_SET);
    ::read(fh, recptr, recsize);
  }
}

                      
//  ------------------------------------------------------------------

void GUser::seekwrite() {

  if(fh != -1) {
    lseek(fh, (long)recno*(long)recsize, SEEK_SET);
    ::write(fh, recptr, recsize);
  }
}

                      
//  ------------------------------------------------------------------

int GUser::find(const char* __name, char* __result, int __wildcards) {

  // Init variables
  index = 0;
  recno = 0;
  found = false;

  // If userfile is open
  if(fh != -1) {

    // Rewind file to start
    lseek(fh, 0, SEEK_SET);

    // Get number of records in the userfile
    records = (uint)(filelength(fh)/recsize);

    // Searching loop
    for(recno=0; recno<records; recno++) {

      // Read a user record
      if(read()) {

        // Compare our name with name in user record
        if(__wildcards) {

          // Compare for wildcard match
          if(strwild(name, __name)) {

            // Copy the name we found
            if(__result)
              strcpy(__result, name);
            founduser();
            break;
          }
        }
        else {

          // Compare for exact, case-insensitive, match
          if(strieql(name, __name)) {
            founduser();
            break;
          }
        }
      }
    }
  }

  // Report the result
  return found;
}


//  ------------------------------------------------------------------

int GUser::findwild(const char* __name, char* __result) {

  return find(__name, __result, true);
}


//  ------------------------------------------------------------------

void GUser::add(const char* __name) {

  recinit(__name);
  recno = records++;
  seekwrite();
  moveto(recno);
  read();
  founduser();
}


//  ------------------------------------------------------------------