KeyHandling.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef KEYHANDLING_H
#define KEYHANDLING_H

#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>

#include "mnstream.h"

typedef u_int64_t u_int64;
typedef u_int32_t u_int32;

template <class T>
class MasterKey {

   public:
   
      //Konstruktor
      MasterKey(const u_int32 Buckets, const u_int32 BucketSize, const u_int32 KeyLength) {
         _Buckets = Buckets;
         _BucketSize = BucketSize;
         _KeyLength = KeyLength;
         _initialized = false;
         _data = NULL;
      }
      
      //Destruktor
      ~MasterKey() {
         deinit();
      }
      
      //init() reserviert leeren Speicher für die Schlüssel
      void init();
      
      //deinit() gibt den von init() reservierten speicher wieder frei
      void deinit() {
         free(_data);
         _data = NULL;
         _initialized = false;
      };

      //Zeiger auf einen Schlüssel zurückgeben
      T* getKey(const u_int32 Bucket, const u_int32 Key) {
         if ( (Bucket > _Buckets) || (Key > _BucketSize) || (!_initialized) )
            return NULL;
         return _data + ( ( (Bucket * _BucketSize) + Key ) * _KeyLength ) * sizeof(T);
      }
      
      //Wert in einen Schlüssel schreiben
      T* setKey(const u_int32 Bucket, const u_int32 Key, const char* const Source) {
         if ( (Bucket > _Buckets) || (Bucket < 0) || (Key > _BucketSize) || (Key < 0) || (!_initialized) || (Source == 0) )
            return NULL;
         T* Destination = _data + ( ( (Bucket * _BucketSize) + Key ) * _KeyLength ) * sizeof(T);
         return (T*)memcpy( Destination, Source, _KeyLength * sizeof(T) );
      
      }

      //Die Länge eines Schlüssels zurückgeben
      u_int32 getKeyLength() { return _KeyLength; };

      //Die Größe eines Buckets zurückgeben
      u_int32 getBucketSize() { return _BucketSize; };

      //Die Anzahl der Buckets zurückgeben
      u_int32 getBucketNumber() { return _Buckets; };

      //readFile() liest einen kompletten Schlüsselsatz aus einer Datei ein.
      //Der Rückgabewert sollte gleich null sein.
      //Wenn er kleiner ist war höchstwahrscheinlich die Datei zu kurz
      int readFile(FILE* file);
      
      //writeFile() schreibt einen kompletten Schlüsselsatz in eine Datei.
      //Der Rückgabewert sollte gleich null sein.
      //Alles anderer bedeutet wahrscheinlich einen Fehler
      int writeFile(FILE* file);

   private:
   
      bool _initialized;
   
      //Anzahl der Buckets
      u_int32 _Buckets;
      
      //Anzahl der Schlüssel in jedem Bucket
      u_int32 _BucketSize;
      
      //Länge eines Schlüssels in T (Schlüssel sind vom Typ T[_KeyLength])
      u_int32 _KeyLength;
      
      //Die Schlüsseldaten
      T* _data;

};


template <class T>
class UserKey {

   public:
   
      //Konstruktor
      UserKey(const u_int32 Buckets, const u_int32 KeyLength);

      //Destruktor
      ~UserKey();

      //ID-String schreiben
      void setID(u_int32 ID[]) { for(u_int32 i=0; i<_Buckets; i++) _ID[i] = ID[i]; };

      //Erzeugt einen Benutzerschlüssel aus einem Masterschlüssel
      //Die Schlüsseldaten werden nicht kopiert. Der Masterschlüssel
      //muß also im Speicher bleiben damit ein so erzeugter Schlüssel
      //funktioniert.
      void readMaster(MasterKey<T>* Master);

      //Liest einen Benutzerschlüssel aus einer Datei
      //Der Rückgabewert sollte gleich null sein.
      //Alles anderer bedeutet wahrscheinlich einen Fehler
      int readFile(FILE* file);
      
      //writeFile() schreibt einen Benutzerschlüssel in eine Datei.
      //Der Rückgabewert sollte gleich null sein.
      //Alles anderer bedeutet wahrscheinlich einen Fehler
      int writeFile(FILE* file);

      //Zeiger auf einen Schlüssel zurückgeben
      T* getKey(u_int32 Number) { return _data[Number]; };

      //ID-Nummer eines Schlüssels ausgeben
      u_int32 getID(u_int32 Number) { return _ID[Number]; };

   private:

      bool _memReserved;

      //Anzahl der Buckets und damit der Schlüssel in einem Benutzerschlüssel
      u_int32 _Buckets;
      
      //Länge eines Schlüssels
      u_int32 _KeyLength;

      //Zeiger auf die Schlüsseldaten
      T** _data;

      //Die Schlüsseldaten selbst (wenn deren Speicher vom Objekt verwaltet wird)
      T* _mem;
      
      //Der ID-String
      u_int32* _ID;
      
};


//init reserviert leeren Speicher für die Schlüssel
template <class T>
void MasterKey<T>::init() {

   if (_initialized) deinit();

   _data = (T*)malloc(_Buckets * _BucketSize * _KeyLength * sizeof(T));

   if (_data == NULL) {
      cerr << __FILE__ << ":" << __LINE__ << " malloc() failed" << endl;
      exit(1);
   }
   
   _initialized = true;
   
}


//readFile liest einen kompletten Schlüsselsatz aus einer Datei ein.
//Der Rückgabewert sollte gleich null sein.
//Wenn er kleiner ist war höchstwahrscheinlich die Datei zu kurz
template <class T>
int MasterKey<T>::readFile(FILE* file) {

   if (!_initialized) init();

   u_int32 ElementCount = fread(_data, sizeof(T)*_KeyLength, _Buckets*_BucketSize, file);

   return ElementCount - _Buckets*_BucketSize;

}


//writeFile() schreibt einen kompletten Schlüsselsatz in eine Datei.
//Der Rückgabewert sollte gleich null sein.
//Alles anderer bedeutet wahrscheinlich einen Fehler
template <class T>
int MasterKey<T>::writeFile(FILE* file) {

   if (!_initialized) return -1;

   u_int32 ElementCount = fwrite(_data, sizeof(T)*_KeyLength, _Buckets*_BucketSize, file);

   return ElementCount - _Buckets*_BucketSize;

}


//Konstruktor
//Erstellt aus einem Masterkey und einem ID-String einen Benutzerschlüssel
//Der ID-String muß Master.getBucketNumber Zeichen lang sein
//Wenn der zur Erzeugung benutzte Masterkey zerstört wird ist auch dieses
//Objekt hinfällig.
template <class T>
UserKey<T>::UserKey(const u_int32 Buckets, const u_int32 KeyLength) {

   _Buckets = Buckets;
   _KeyLength = KeyLength;

   _ID = new u_int32[Buckets];
   _data = new T*[Buckets];

   _memReserved = false;

}


//Destruktor
template <class T>
UserKey<T>::~UserKey() {

   if (_memReserved) free(_mem);

   delete[] _ID;
   delete[] _data;

}


//Erzeugt einen Benutzerschlüssel aus einem Masterschlüssel
template <class T>
void UserKey<T>::readMaster(MasterKey<T>* Master) {

   for(u_int32 counter=0; counter < _Buckets; counter++)
      _data[counter] = Master->getKey(counter, _ID[counter]);

};


//Liest einen Benutzerschlüssel aus einer Datei
//Der Rückgabewert sollte gleich null sein.
//Alles anderer bedeutet wahrscheinlich einen Fehler
template <class T>
int UserKey<T>::readFile(FILE* file) {

   u_int32 KeyBytes = _KeyLength * sizeof(T);

   if (!_memReserved) {

      _mem = (T*)malloc(_Buckets * KeyBytes);

      if (_mem == NULL) {
         cerr << __FILE__ << ":" << __LINE__ << " malloc() failed" << endl;
         exit(1);
      }

   }

   u_int32 ElementCount = fread(_mem, KeyBytes, _Buckets, file);

   for(u_int32 counter=0; counter < _Buckets; counter++)
      _data[counter] = _mem + counter * KeyBytes;

   return ElementCount - _Buckets;

};


//writeFile() schreibt einen Benutzerschlüssel in eine Datei.
//Der Rückgabewert sollte gleich null sein.
//Alles anderer bedeutet wahrscheinlich einen Fehler
template <class T>
int UserKey<T>::writeFile(FILE* file) {

   u_int32 counter;

   u_int32 KeyBytes = _KeyLength * sizeof(T);

   for(counter=0; counter < _Buckets; counter++) {

      u_int32 n = fwrite(_data[counter], KeyBytes, 1, file);
      if (n != 1) { counter--; break; }

   }

   return counter - _Buckets;

}


#endif

---