Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members   Examples  

datatypes.h

Go to the documentation of this file.
00001 
00002 //
00003 // YASA datatypes declarations
00004 //
00005 // Project: Yasa 2
00006 // Author : Jan Blumenthal
00007 // Start  : 2002/02/28
00008 // $Header: /sources/yasa/yasagui/datatypes.h,v 1.5 2003/01/24 15:47:40 bj Exp $
00009 //
00011 //
00012 // This program is free software; you can redistribute it and/or modify
00013 // it under the terms of the GNU General Public License as published by
00014 // the Free Software Foundation; either version 2 of the License, or
00015 // (at your option) any later version.
00016 //
00017 // This program is distributed in the hope that it will be useful,
00018 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00019 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00020 // GNU General Public License for more details.
00021 //
00022 // You should have received a copy of the GNU General Public License
00023 // along with this program (See the included file COPYING);
00024 // if not, write to the Free Software Foundation, Inc.,
00025 // 675 Mass Ave, Cambridge, MA 02139, USA.
00026 //
00028 #ifndef YASAGUI_DATATYPES_INCLUDE
00029 #define YASAGUI_DATATYPES_INCLUDE
00030 
00031 #include "object.h"
00032 
00033 
00035 //Typedef_YDerivedObject(QString, YString)
00036 class YString : public YDerivedType<QString>
00037 {
00038 public:             YString(const QString &c=QString::null) :
00039                     YDerivedType<QString>(c)
00040                     {}
00041     virtual QString GetContentString() const                    {   return GetContent();                    }
00042     virtual QString GetVisibleContentString() const             {   return GetContent();                    }
00043     static QString  Justify(QString tmp, int width=YASATIME_JUSTIFYNUMBER, QChar fillchar=YASATIME_JUSTIFYFILL);
00044     virtual int     ReadFromString(const QString &s)            {   SetContent(s);
00045                                                                     return 0;                               }
00046     const QString&  operator = (const QString &c)               {   return SetContent(c);                   }
00047     // base class is a type of QString!
00048     //                  operator QString() const                    {   return GetContent();                    }
00049 };
00050 
00051 
00053 typedef INT64   YASA_TIME;
00054 
00055 
00057 class YTIME : public YDerivedType<YASA_TIME>
00058 {
00059 public:             YTIME(YASA_TIME t=YASA_TIME_MIN): YDerivedType<YASA_TIME>(t) {}
00060                     YTIME(const YTIME *t)           : YDerivedType<YASA_TIME>(t) {}
00061     enum            { YASA_SHORT_INFINITY_TIME=-1, YASA_TIME_MIN=0, YASA_TIME_INT_MAX=0x7fffffff };
00062     virtual QString GetContentString()  const;
00063     static QString  GetContentString(YASA_TIME time);
00064     static QString  GetContentStringMax(YASA_TIME time);
00065     static QString  GetSourceString(YASA_TIME time);
00066     static YASA_TIME ReadYasaTimeFromString(const QString &str, bool *ok);
00067     QString         GetVisibleContentString() const;
00068     static QString  GetVisibleContentString(YASA_TIME time);
00069     virtual int     ReadFromString(const QString &s);
00070     bool            IsInfinity() const                          {   return GetContent()==YASA_TIME_INFINITY;}
00071     YASA_TIME       operator - (const YTIME &t) const           {   return GetContent() -  t.GetContent();  }
00072     bool            operator < (const YTIME &t) const           {   return GetContent() <  t.GetContent();  }
00073     bool            operator <=(const YTIME &t) const           {   return GetContent() <= t.GetContent();  }
00074     bool            operator > (const YTIME &t) const           {   return GetContent() >  t.GetContent();  }
00075     bool            operator >=(const YTIME &t) const           {   return GetContent() >= t.GetContent();  }
00076     const YASA_TIME& operator = (const YASA_TIME &c)            {   return SetContent(c);                   }
00077 // should be removed in future
00078                     operator YASA_TIME() const                  {   return GetContent();                    }
00079 
00082     virtual bool    CheckLimits(YASA_TIME &dest, const YASA_TIME &source) const
00083                                                                 {
00084                                                                     if ( source == -1 )
00085                                                                     {
00086                                                                         dest=YASA_TIME_INFINITY;
00087                                                                         return true;
00088                                                                     }
00089                                                                     if ( source < YASA_TIME_MIN )
00090                                                                     {
00091                                                                         qWarning("YASA_TIME::SetTime() called with illegal arguments");
00092                                                                         dest=YASA_TIME_MIN;
00093                                                                         return true;
00094                                                                     }
00095                                                                     dest=source;
00096                                                                     return true;
00097                                                                 }
00098 };
00099 
00100 
00102 class YASA_PERIOD : public YTIME
00103 {public:            YASA_PERIOD(YASA_TIME t=YASA_TIME_INFINITY) : YTIME(t)                                { }
00104                     YASA_PERIOD(const YTIME *t)                 : YTIME(t)                                { }
00105     const YASA_TIME& operator = (const YASA_TIME &c)            {   return SetContent(c);                   }
00106 };
00108 class YASA_DEADLINE : public YTIME
00109 {public:            YASA_DEADLINE(YASA_TIME t=YASA_TIME_INFINITY): YTIME(t)                               { }
00110                     YASA_DEADLINE(const YTIME *t)               : YTIME(t)                                { }
00111     const YASA_TIME& operator = (const YASA_TIME &c)            {   return SetContent(c);                   }
00112     virtual bool    CheckLimits(YASA_TIME &dest, const YASA_TIME &source) const
00113                                                                 {
00114                                                                     if ( source <= 0 )
00115                                                                     {
00116                                                                         dest=YASA_TIME_INFINITY;
00117                                                                         return true;
00118                                                                     }
00119                                                                     dest=source;
00120                                                                     return true;
00121                                                                 }
00122 };
00124 class YASA_DEADLINETOLERANCE : public YTIME
00125 {public:            YASA_DEADLINETOLERANCE(YASA_TIME t=0)       : YTIME(t)                                { }
00126                     YASA_DEADLINETOLERANCE(const YTIME *t)      : YTIME(t)                                { }
00127     const YASA_TIME& operator = (const YASA_TIME &c)            {   return SetContent(c);                   }
00128 };
00130 class YASA_LAXITY : public YTIME
00131 {public:            YASA_LAXITY(YASA_TIME t=YASA_TIME_INFINITY) : YTIME(t)                                { }
00132                     YASA_LAXITY(const YTIME *t)                 : YTIME(t)                                { }
00133     const YASA_TIME& operator = (const YASA_TIME &c)            {   return SetContent(c);                   }
00134 };
00136 class YASA_REQUIREDTIME : public YTIME
00137 {public:            YASA_REQUIREDTIME(YASA_TIME t=0/*YASA_MIN_REQUIRED_TIME*/)  : YTIME(t)                    { }
00138                     YASA_REQUIREDTIME(const YTIME *t)           : YTIME(t)                                { }
00139     const YASA_TIME& operator = (const YASA_TIME &c)            {   return SetContent(c);                   }
00140 };
00142 class YASA_OFFSET : public YTIME
00143 {public:            YASA_OFFSET(YASA_TIME t=0)                  : YTIME(t)                                { }
00144                     YASA_OFFSET(const YTIME *t)                 : YTIME(t)                                { }
00145     const YASA_TIME& operator = (const YASA_TIME &c)            {   return SetContent(c);                   }
00146 };
00148 class YASA_SCHEDULINGTIME : public YTIME
00149 {public:            YASA_SCHEDULINGTIME(YASA_TIME t=0)          : YTIME(t)                                { }
00150                     YASA_SCHEDULINGTIME(const YTIME *t)         : YTIME(t)                                { }
00151     const YASA_TIME& operator = (const YASA_TIME &c)            {   return SetContent(c);                   }
00152 };
00154 class YASA_SYNCHRONIZATIONOFFSET : public YTIME
00155 {public:            YASA_SYNCHRONIZATIONOFFSET(YASA_TIME t=0)   : YTIME(t)                                { }
00156                     YASA_SYNCHRONIZATIONOFFSET(const YTIME *t)  : YTIME(t)                                { }
00157     const YASA_TIME& operator = (const YASA_TIME &c)            {   return SetContent(c);                   }
00158 };
00161 class YASA_TICK : public YTIME
00162 {   YASA_TIME       min_tick;
00163 public:             YASA_TICK(YASA_TIME t=YASA_TIME_INFINITY)   : YTIME(t), min_tick(YASA_TIME_MIN)       { }
00164                     YASA_TICK(const YTIME *t)                   : YTIME(t), min_tick(YASA_TIME_MIN)       { }
00165     void            SetMinTimerTick(YASA_TIME t);
00166     virtual bool    CheckLimits(YASA_TIME &dest, const YASA_TIME &source) const;
00167     const YASA_TIME& operator = (const YASA_TIME &c)            {   return SetContent(c);                               }
00168     virtual QString GetVisibleContentString()   const           {   if ( (GetContent() == (YASA_TIME)YTIME::YASA_TIME_MIN)      ||
00169                                                                          (GetContent() == (YASA_TIME)YTIME::YASA_TIME_INT_MAX)  ||
00170                                                                          IsInfinity()                                           )
00171                                                                          return MSGP_YASA_TIME_INFINITY;
00172                                                                     return QString::number( (long)GetContent() );       }
00173 
00174 
00175 };
00176 
00177 
00178 
00179 
00180 
00181 
00183 class YASA_PRIORITY : public YDerivedType<int>
00184 {public:            YASA_PRIORITY(int p=YG_MIN_PRIORITY) :  YDerivedType<int>(p) {}
00185                     YASA_PRIORITY(const YASA_PRIORITY *p):  YDerivedType<int>(p) {}
00186     virtual QString GetContentString()  const                           {   return QString::number( GetContent() );     }
00187     virtual QString GetVisibleContentString()   const                   {   return QString::number( GetContent() );     }
00188     virtual int     ReadFromString(const QString &s);
00189     int             operator - (const YASA_PRIORITY &p) const   {   return GetContent() -  p.GetContent();      }
00190     bool            operator < (const YASA_PRIORITY &p) const   {   return GetContent() <  p.GetContent();      }
00191     bool            operator <=(const YASA_PRIORITY &p) const   {   return GetContent() <= p.GetContent();      }
00192     bool            operator > (const YASA_PRIORITY &p) const   {   return GetContent() >  p.GetContent();      }
00193     bool            operator >=(const YASA_PRIORITY &p) const   {   return GetContent() >= p.GetContent();      }
00194                     operator int() const                        {   return (int)GetContent();                   }
00195     const int&      operator = (const int &c)                       {   return SetContent(c);                               }
00196     virtual bool    CheckLimits(int &dest, const int &source) const
00197                                                                 {   if ( source < YG_MIN_PRIORITY )
00198                                                                     {   qWarning("YASA_PRIORITY::SetPriority() called with illegal arguments");
00199                                                                         dest=YG_MIN_PRIORITY;
00200                                                                         return true;
00201                                                                     }
00202                                                                     if ( source > YG_MAX_PRIORITY )
00203                                                                     {   qWarning("YASA_PRIORITY::SetPriority() called with illegal arguments");
00204                                                                         dest=YG_MAX_PRIORITY;
00205                                                                         return true;
00206                                                                     }
00207                                                                     dest=source;
00208                                                                     return true;
00209                                                                 }
00210 
00211 };
00212 
00213 
00220 class YASA_CPU : public YDerivedType<int>
00221 {public:            YASA_CPU(int c=YG_MIN_CPU) : YDerivedType<int>(c) {}
00222                     YASA_CPU(const YASA_CPU *c, int c2=YG_MIN_CPU) : YDerivedType<int>(c2,c) {}
00223     virtual QString GetContentString() const                    {   return QString::number( GetContent() );         }
00224     virtual QString GetVisibleContentString() const             {   return QString::number( GetContent() );         }
00225     virtual int     GetMinValue() const                         {   return YG_MIN_CPU;                              }
00226     virtual int     ReadFromString(const QString &s);
00227     bool            operator < (const YASA_CPU &c) const        {   return GetContent() <  c.GetContent();          }
00228     bool            operator <=(const YASA_CPU &c) const        {   return GetContent() <= c.GetContent();          }
00229     bool            operator > (const YASA_CPU &c) const        {   return GetContent() >  c.GetContent();          }
00230     bool            operator >=(const YASA_CPU &c) const        {   return GetContent() >= c.GetContent();          }
00231     const int&      operator = (const int &c)                   {   return SetContent(c);                           }
00232                     operator int() const                        {   return (int)GetContent();                       }
00233     virtual bool    CheckLimits(int &dest, const int &source) const;
00234 };
00235 
00240 class YASA_MAXCPU : public YASA_CPU
00241 {public:            YASA_MAXCPU(int c=YG_DEFAULT_NUMBER_OF_CPUS) :
00242                     YASA_CPU(c)
00243                     {}
00244                     YASA_MAXCPU(const YASA_CPU *c) :
00245                     YASA_CPU(c)
00246                     {}
00247     virtual int     GetMinValue() const                         {   return 1;                                       }
00248     bool            operator < (const YASA_CPU &c) const        {   return GetContent() <  c.GetContent();          }
00249     bool            operator <=(const YASA_CPU &c) const        {   return GetContent() <= c.GetContent();          }
00250     bool            operator > (const YASA_CPU &c) const        {   return GetContent() >  c.GetContent();          }
00251     bool            operator >=(const YASA_CPU &c) const        {   return GetContent() >= c.GetContent();          }
00252     const int&      operator = (const int &c)                   {   return SetContent(c);                           }
00253                     operator int() const                        {   return (int)GetContent();                       }
00254     virtual bool    CheckLimits(int &dest, const int &source) const;
00255     enum            { YASA_FLEXIBLE_MAX_CPU=0 };
00256 };
00257 
00258 
00260 /*
00261 class YASA_REQUIREDVERSION : public YDerivedType<double>
00262 {public:            YASA_REQUIREDVERSION(double v=YASA_VERSION)  : YDerivedType<double>(v)                          {}
00263                     YASA_REQUIREDVERSION(const YASA_REQUIREDVERSION *t): YDerivedType<double>(t)                    {}
00264     virtual QString GetContentString() const                    {   return QString::number( GetContent() );         }
00265     virtual QString GetVisibleContentString() const             {   return QString::number( GetContent() );         }
00266     virtual int     ReadFromString(const QString &s);
00267                     operator double() const                     {   return (double)GetContent();                    }
00268     const int&      operator = (const int &c)                   {   return SetContent(c);                           }
00269     virtual bool    CheckLimits(double &dest, const double &source) const
00270                                                                 {   if ( source > YASA_VERSION )
00271                                                                     {   qWarning("YASA_REQUIREDVERSION::SetTaskType() called with illegal arguments");
00272                                                                         dest=YASA_THREAD_MINTYPE;
00273                                                                         return true;
00274                                                                     }
00275                                                                     if ( source > YASA_THREAD_MAXTYPE )
00276                                                                     {   qWarning("YASA_TASKTYPE::SetTaskType() called with illegal arguments");
00277                                                                         dest=YASA_THREAD_MAXTYPE;
00278                                                                         return true;
00279                                                                     }
00280                                                                     dest=source;
00281                                                                     return true;
00282                                                                 }
00283 };
00284 */
00285 
00287 class YASA_TASKTYPE : public YDerivedType<int>
00288 {public:            YASA_TASKTYPE(int t=YG_MIN_CPU)      : YDerivedType<int>(t) {}
00289                     YASA_TASKTYPE(const YASA_TASKTYPE *t): YDerivedType<int>(t) {}
00290     virtual QString GetContentString() const                    {   return QString::number( GetContent() );     }
00291     virtual QString GetVisibleContentString() const             {   return QString::number( GetContent() );     }
00292     virtual int     ReadFromString(const QString &s);
00293                     operator int() const                        {   return (int)GetContent();                   }
00294     const int&      operator = (const int &c)                   {   return SetContent(c);                               }
00295     virtual bool    CheckLimits(int &dest, const int &source) const
00296                                                                 {   if ( source < YASA_THREAD_MINTYPE )
00297                                                                     {   qWarning("YASA_TASKTYPE::SetTaskType() called with illegal arguments");
00298                                                                         dest=YASA_THREAD_MINTYPE;
00299                                                                         return true;
00300                                                                     }
00301                                                                     if ( source > YASA_THREAD_MAXTYPE )
00302                                                                     {   qWarning("YASA_TASKTYPE::SetTaskType() called with illegal arguments");
00303                                                                         dest=YASA_THREAD_MAXTYPE;
00304                                                                         return true;
00305                                                                     }
00306                                                                     dest=source;
00307                                                                     return true;
00308                                                                 }
00309 };
00310 
00311 
00313 class YASA_SCHEDULERTYPE : public YDerivedType<int>
00314 {public:            YASA_SCHEDULERTYPE(int t=YASA_SCHEDULER_STATIC) : YDerivedType<int>(t)  {}
00315                     YASA_SCHEDULERTYPE(const YASA_SCHEDULERTYPE *t) : YDerivedType<int>(t)  {}
00316     virtual QString GetContentString() const                            {   return QString::number( GetContent() );     }
00317     virtual QString GetVisibleContentString() const                 {   return QString::number( GetContent() );     }
00318     virtual int     ReadFromString(const QString &s);
00319                     operator int() const                        {   return (int)GetContent();                       }
00320     const int&      operator = (const int &c)                       {   return SetContent(c);                               }
00321     virtual bool    CheckLimits(int &dest, const int &source) const
00322                                                                 {   if ( source < YASA_SCHEDULER_MINTYPE )
00323                                                                     {   qWarning("YASA_SCHEDULERTYPE::SetTaskType() called with illegal arguments");
00324                                                                         dest=YASA_SCHEDULER_MINTYPE;
00325                                                                         return true;
00326                                                                     }
00327                                                                     if ( source > YASA_SCHEDULER_MAXTYPE )
00328                                                                     {   qWarning("YASA_SCHEDULERTYPE::SetTaskType() called with illegal arguments");
00329                                                                         dest=YASA_SCHEDULER_MAXTYPE;
00330                                                                         return true;
00331                                                                     }
00332                                                                     dest=source;
00333                                                                     return true;
00334                                                                 }
00335 
00336 };
00337 
00338 
00340 class YASA_SERVERTYPE : public YDerivedType<int>
00341 {public:            YASA_SERVERTYPE(int t=YG_MIN_CPU)        :  YDerivedType<int>(t) {}
00342                     YASA_SERVERTYPE(const YASA_SERVERTYPE *t):  YDerivedType<int>(t) {}
00343     virtual QString GetContentString() const                            {   return QString::number( GetContent() );         }
00344     virtual QString GetVisibleContentString() const                 {   return QString::number( GetContent() );         }
00345     virtual int     ReadFromString(const QString &s);
00346                     operator int() const                        {   return (int)GetContent();                       }
00347     const int&      operator = (const int &c)                       {   return SetContent(c);                               }
00348     virtual bool    CheckLimits(int &dest, const int &source) const
00349                                                                 {   if ( source < YASA_THREAD_MINTYPE )
00350                                                                     {   qWarning("YASA_SERVERTYPE::SetServerType() called with illegal arguments");
00351                                                                         dest=YASA_THREAD_MINTYPE;
00352                                                                         return true;
00353                                                                     }
00354                                                                     if ( source > YASA_THREAD_MAXTYPE )
00355                                                                     {   qWarning("YASA_SERVERTYPE::SetServerType() called with illegal arguments");
00356                                                                         dest=YASA_THREAD_MAXTYPE;
00357                                                                         return true;
00358                                                                     }
00359                                                                     dest=source;
00360                                                                     return true;
00361                                                                 }
00362 };
00363 
00364 
00365 
00367 class YASA_DLBEHAVIOUR : public YDerivedType<int>
00368 {public:            YASA_DLBEHAVIOUR(int b=YASA_DL_IGNORE)      : YDerivedType<int>(b)  {}
00369                     YASA_DLBEHAVIOUR(const YASA_DLBEHAVIOUR *b) : YDerivedType<int>(b)  {}
00370     virtual QString GetContentString() const                            {   return QString::number( GetContent() );     }
00371     virtual QString GetVisibleContentString() const                 {   return QString::number( GetContent() );     }
00372     virtual int     ReadFromString(const QString &s);
00373                     operator int() const                        {   return (int)GetContent();                   }
00374     const int&      operator = (const int &c)                       {   return SetContent(c);                               }
00375     virtual bool    CheckLimits(int &dest, const int &source) const
00376                                                                 {   if ( source < YASA_DL_MIN )
00377                                                                     {   qWarning("YASA_DLBEHAVIOUR::SetDLBehaviour() called with illegal arguments");
00378                                                                         dest=YASA_DL_MIN;
00379                                                                         return true;
00380                                                                     }
00381                                                                     if ( source > YASA_DL_MAX )
00382                                                                     {   qWarning("YASA_DLBEHAVIOUR::SetDLBehaviour() called with illegal arguments");
00383                                                                         dest=YASA_DL_MAX;
00384                                                                         return true;
00385                                                                     }
00386                                                                     dest=source;
00387                                                                     return true;
00388                                                                 }
00389 };
00390 
00391 
00393 class YASA_MUTEXPROTOCOL : public YDerivedType<int>
00394 {public:            YASA_MUTEXPROTOCOL(int p=YASASP_NOTHING)        : YDerivedType<int>(p) {}
00395                     YASA_MUTEXPROTOCOL(const YASA_MUTEXPROTOCOL *p) : YDerivedType<int>(p) {}
00396     virtual QString GetContentString() const                            {   return QString::number( GetContent() );     }
00397     virtual QString GetVisibleContentString() const                 {   return QString::number( GetContent() );     }
00398     virtual int     ReadFromString(const QString &s);
00399                     operator int() const                        {   return (int)GetContent();                   }
00400     const int&      operator = (const int &c)                       {   return SetContent(c);                               }
00401 
00402     virtual bool    CheckLimits(int &dest, const int &source) const
00403                                                                 {   if ( source < YASASP_MIN )
00404                                                                     {   qWarning("YASA_MUTEXPROTOCOL::SetMutexProtocol() called with illegal arguments");
00405                                                                         dest=YASASP_MIN;
00406                                                                         return true;
00407                                                                     }
00408                                                                     if ( source > YASASP_MAX )
00409                                                                     {   qWarning("YASA_MUTEXPROTOCOL::SetMutexProtocol() called with illegal arguments");
00410                                                                         dest=YASASP_MAX;
00411                                                                         return true;
00412                                                                     }
00413                                                                     dest=source;
00414                                                                     return true;
00415                                                                 }
00416 
00417 };
00418 
00419 
00421 class YASA_RESOURCEACTION : public YDerivedType<int>
00422 {public:            YASA_RESOURCEACTION(int p=YASAA_NO_MORE_ACTION)  : YDerivedType<int>(p) {}
00423                     YASA_RESOURCEACTION(const YASA_RESOURCEACTION *p): YDerivedType<int>(p) {}
00424     virtual QString GetContentString() const                    {   return QString::number( GetContent() );     }
00425     virtual QString GetVisibleContentString() const             {   return QString::number( GetContent() );     }
00426     virtual int     ReadFromString(const QString &s);
00427                     operator int() const                        {   return (int)GetContent();                   }
00428     const int&      operator = (const int &c)                   {   return SetContent(c);                               }
00429     virtual bool    CheckLimits(int &dest, const int &source) const
00430                                                                 {   if ( source < YASAA_ACTION_MIN )
00431                                                                     {   qWarning("YASA_RESOURCEACTION::SetResourceAction() called with illegal arguments");
00432                                                                         dest=YASAA_ACTION_MIN;
00433                                                                         return true;
00434                                                                     }
00435                                                                     if ( source > YASAA_ACTION_MAX )
00436                                                                     {   qWarning("YASA_RESOURCEACTION::SetResourceAction() called with illegal arguments");
00437                                                                         dest=YASAA_ACTION_MAX;
00438                                                                         return true;
00439                                                                     }
00440                                                                     dest=source;
00441                                                                     return true;
00442                                                                 }
00443 };
00444 
00445 
00447 class YASA_CALCPREEMPTIONTIME : public YDerivedType<bool>
00448 {public:            YASA_CALCPREEMPTIONTIME(bool b=SUPPORT_CALC_PREEMPTIONTIME) : YDerivedType<bool>(b) {}
00449                     YASA_CALCPREEMPTIONTIME(const YASA_CALCPREEMPTIONTIME *b): YDerivedType<bool>(b) {}
00450     virtual QString GetContentString() const                    {   return QString::number( GetContent() );     }
00451     virtual QString GetVisibleContentString() const             {   return QString::number( GetContent() );     }
00452     virtual int     ReadFromString(const QString &s);
00453                     operator bool() const                       {   return GetContent();                        }
00454     virtual bool    CheckLimits(bool &dest, const bool &source) const;
00455     const bool&     operator = (const bool &c)                  {   return SetContent(c);                               }
00456 };
00457 
00459 class YASA_TIMERTICK : public YDerivedType<bool>
00460 {public:            YASA_TIMERTICK(bool b=SUPPORT_TIMERTICK) : YDerivedType<bool>(b) {}
00461                     YASA_TIMERTICK(const YASA_TIMERTICK *b): YDerivedType<bool>(b) {}
00462     virtual QString GetContentString() const                    {   return QString::number( GetContent() );     }
00463     virtual QString GetVisibleContentString() const             {   return QString::number( GetContent() );     }
00464     virtual int     ReadFromString(const QString &s);
00465                     operator bool() const                       {   return GetContent();                        }
00466     virtual bool    CheckLimits(bool &dest, const bool &source) const;
00467     const bool&     operator = (const bool &c)                  {   return SetContent(c);                               }
00468 };
00469 
00470 
00472 #endif                                                                  // ifndef YASAGUI_CONFIG_INCLUDE

Generated on Thu Feb 13 23:43:52 2003 for Yasa by doxygen1.3-rc3