Timehasp.h

Go to the documentation of this file.

/*
 *  TIMEHASP.H - A C++ header for TimeHASP related classes.
 *
 *  Copyright (c) 1998 Aladdin Knowledge Systems Ltd.
 */

#if !defined (TIMEHASP_H_)
#define TIMEHASP_H_

#include <time.h>

#if !defined (LOCALHASP_H_)
#include "loclhasp.h"
#endif

#if !defined (HASPMEM_H_)
#include "haspmem.h"
#endif


// HASP namespace support.
//
BEGIN_HASP_NAMESPACE


// Forward Declarations
//
class TimehaspDate;
class TimehaspTime;


// class TimeHasp
// ~~~~~ ~~~~~~~~
// class TimeHasp represents the real key TimeHASP.
//
class TimeHasp : public LocalHasp, public HaspWithMemory
{
public:
   typedef unsigned char  MemoType;

   // construction/destruction.
   //
   HASP_EXPORT TimeHasp( LocalHaspImp* );
   HASP_EXPORT TimeHasp( unsigned int  pass1,
                         unsigned int  pass2,
                         HaspErrorProc handler = 0,
                         unsigned int  lptnum = 0 );

   virtual      HASP_EXPORT ~TimeHasp();
   virtual void HASP_EXPORT Accept( HaspApplicator& );

   
   // Clock operations
   //
   void HASP_EXPORT GetTime(TimehaspTime& Time) const;
   void HASP_EXPORT SetTime(const TimehaspTime& Time);
   void HASP_EXPORT GetDate(TimehaspDate& Date) const;
   void HASP_EXPORT SetDate(const TimehaspDate& Date);

private:

   // TimeHASP-4 support.
   //
   friend class MemohaspConverter;
   
   // not implemented copy ctor and operator =
   //
   TimeHasp(const TimeHasp&);
   TimeHasp& operator=(const TimeHasp& rhs);
};


// class MemohaspConverter
// ~~~~~ ~~~~~~~~~~~~~~~~~
// TimeHASP-4 is a combination of a TimeHASP and a MemoHASP-4.
// When you create a TimeHasp object for a TimeHASP-4 key, the
// memory operations access and modify the TimeHASP part.
//
// The role of MemohaspConverter is to change the memory region
// to that of the MemoHASP-4 part.
// 
// MemohaspConverter has no effect if the TimeHasp object does not
// represent a TimeHASP-4.
//
class MemohaspConverter
{
public:
   HASP_EXPORT MemohaspConverter(const TimeHasp& key);
   HASP_EXPORT ~MemohaspConverter();

   // returns 'true' for TimeHASP-4 and 'false' for TimeHASP
   //
   operator bool() const { return converted; }

   // restores default memory operations (i.e. TimeHASP). This operation
   // is done automatically in the destructor but can be done earlier.
   //
   HASP_EXPORT void Restore();

private:
   const TimeHasp* pkey;
   bool converted;
   
   // prevent copy and assignment
   //
   MemohaspConverter(const MemohaspConverter&);
   MemohaspConverter& operator=(const MemohaspConverter&);
};


// THDay, THYear, THMonth
// ~~~~~~~~~~~~~~~~~~~~~~
// types to represent day, month, year for better type checking.
//
typedef int THDay;

enum THYear
{
   TH_MINYEAR = 1992,
   TH_MAXYEAR = 2091
};

enum THMonth
{
   TH_JAN = 1,
   TH_FEB = 2,
   TH_MAR = 3,
   TH_APR = 4,
   TH_MAY = 5,
   TH_JUN = 6,
   TH_JUL = 7,
   TH_AUG = 8,
   TH_SEP = 9,
   TH_OCT = 10,
   TH_NOV = 11,
   TH_DEC = 12
};


// class TimehaspDate.
// ~~~~~ ~~~~~~~~~~~~
// helper class for GetDate and SetDate services.
//
class TimehaspDate
{
   friend class TimeHasp;

public:
   // Initialization constants.
   //
   enum { Default = -1, Today = 0 };

   // construction
   //
   explicit HASP_EXPORT TimehaspDate(time_t aTime = Default);
   HASP_EXPORT TimehaspDate(THMonth mm, THDay dd, THYear yy);

   bool Valid()   const { return valid; }
   int  Month()   const { return month; }
   int  Day()     const { return day;   }
   int  Year()    const { return year;  }
   int  APIYear() const { return year % 100; }

private:
   void Init(time_t aTime);
   void Check();

   int month;
   int day;
   int year;
   bool valid;
};



// class TimehaspTime.
// ~~~~~ ~~~~~~~~~~~~
// helper class for GetTime and SetTime services.
//
class TimehaspTime
{
   friend class TimeHasp;
   
public:
   // Initialization constants.
   //
   enum { Default = -1, Now = 0 };

   // construction.
   // Note: default generated copy constructor and operator= are OK here.
   //
   explicit HASP_EXPORT TimehaspTime(time_t aTime = Default);
   HASP_EXPORT TimehaspTime(int hh, int mm, int ss);

   bool Valid()  const { return valid;  }
   int  Hour()   const { return hour;   }
   int  Minute() const { return minute; }
   int  Second() const { return second; }

private:
   void Init(time_t aTime);
   void Check();
   
   int hour;
   int minute;
   int second;
   bool valid;
};


END_HASP_NAMESPACE


#endif // TIMEHASP_H_

---