yb_base.h

网吧电量采集、温湿度采集串口通信实例程序

//////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------
class PACKAGE TVictorStringList
{
public:
  __property int Count               = { read = fGetCount, write = fSetCount };
  __property TVictorString Item[int] = { read = fGetItem , write = fSetItem  };
  __property TVictorString Text      = { read = fGetText , write = fSetText  };
  __property TVictorString Value[TVictorString] = { read = fGetValue, write = fSetValue };

  virtual void Add(TVictorString s);
  virtual void Insert(TVictorString s, int idx);
  virtual void Delete(int idx);
  virtual void Clear(void) { Count=0; }

  virtual int IndexOf(TVictorString s); //-1: not found

  TVictorStringList();
  TVictorStringList(TVictorString s);
  TVictorStringList(const TVictorStringList &sl);
  virtual ~TVictorStringList() { Clear(); }

private:
  std::vector<TVictorString>_Items;
  int fGetCount(void) const { return _Items.size(); }
  void fSetCount(int n) { _Items.resize(n); }
  TVictorString fGetItem(int idx) const;
  void fSetItem(int idx, const TVictorString &s);
  TVictorString fGetText(void) const;
  void fSetText(TVictorString s);
  TVictorString fGetValue(TVictorString sItem) const;
  void fSetValue(TVictorString sItem, TVictorString sNewValue);
  void fStrToNameValue(TVictorString s, TVictorString &n, TVictorString &v) const;
};
//----------------------------------------------------------------------------
class PACKAGE TVictorWideStringList
{
public:
  __property int Count                   = { read = fGetCount, write = fSetCount };
  __property TVictorWideString Item[int] = { read = fGetItem , write = fSetItem  };
  __property TVictorWideString Text      = { read = fGetText , write = fSetText  };
  __property TVictorWideString Value[TVictorWideString] = { read = fGetValue, write = fSetValue };

  virtual void Add(TVictorWideString s);
  virtual void Insert(TVictorWideString s, int idx);
  virtual void Delete(int idx);
  virtual void Clear(void) { Count=0; }

  virtual int IndexOf(TVictorWideString ws); //-1: not found

  TVictorWideStringList();
  TVictorWideStringList(TVictorWideString s);
  TVictorWideStringList(const TVictorWideStringList &sl);
  virtual ~TVictorWideStringList() { Clear(); }

private:
  std::vector<TVictorWideString>_Items;
  int fGetCount(void) const { return _Items.size(); }
  void fSetCount(int n) { _Items.resize(n); }
  TVictorWideString fGetItem(int idx) const;
  void fSetItem(int idx, const TVictorWideString &s);
  TVictorWideString fGetText(void) const;
  void fSetText(TVictorWideString s);
  TVictorWideString fGetValue(TVictorWideString sItem) const;
  void fSetValue(TVictorWideString sItem, TVictorWideString sNewValue);
  void fStrToNameValue(TVictorWideString s, TVictorWideString &n, TVictorWideString &v) const;
};
//----------------------------------------------------------------------------
//////////////////////////////////////////////////////////////////////////////
//----------------------------------------------------------------------------
class PACKAGE TAppLang
{
public:
  typedef struct
   {
     unsigned char qm;
     unsigned char wm;
   } CHINESE_CHAR;

  enum TLangType
   {
     ltAnsi = 1, //ANSI_CHARSET
     ltGbk  = 2, //GB2312_CHARSET
     ltBig5 = 3, //CHINESEBIG5_CHARSET
   };

  enum TDetectType
   {
     dtAuto     = 0, //All Auto
     dtManual   = 1, //User Defined
   };

public:
  __property LANGID        SysLangId   = { read = _SysLangId}; //readonly property
  __property TLangType     LangType    = { read = _LangType  , write = fSetLangType   };

  __property TVictorString FontName    = { read = _FontName  , write = fSetFontName   };
  __property TFontCharset  Charset     = { read = _Charset   , write = fSetCharset    };
  __property int           FontSize    = { read = _FontSize  , write = fSetFontSize   };

  __property int           MinFontSize = { read = _fGetMinFontSize }; //readonly property
  __property TDetectType   DetectType  = { read = _DetectType, write = fSetDetectType };
  __property TVictorString PdxLangDrv  = { read = fGetPdxLangDrv }; //readonly property, get Paradox Language Driver from LangType

  __property bool          CvtBig5     = { read = _bTransBig5, write = fSetCvtBig5    };

  TVictorString __fastcall FromGBK(TVictorString s); //convert GBK Triditional Chinese to Big5 Triditional Chinese

  __fastcall TAppLang(); //Set DetectType to dtAuto by default
  virtual __fastcall ~TAppLang();

private:
  void __fastcall fSetLangType(TLangType t); //-> DetectType, FontName, Charset, FontSize
  void __fastcall fSetFontName(TVictorString s);
  void __fastcall fSetCharset(TFontCharset c); //-> DetectType, LangType
  void __fastcall fSetFontSize(int i);
  void __fastcall fSetDetectType(TDetectType dtType); //-> LangType, FontName, CharSet, FontSize

  TVictorString __fastcall fGetPdxLangDrv(void); //Get Paradox Language Driver from LangType
  void __fastcall fSetCvtBig5(bool);

  int  __fastcall _fGBK_No(unsigned char qm, unsigned char wm);
  int  __fastcall _fGetMinFontSize(void);
  void __fastcall _fLangTypeFromCharset(void);      //Charset    -> LangType
  void __fastcall _fLangTypeFromDetectType(void);   //DetectType -> LangType
  void __fastcall _fCharsetFromLangType(void);      //LangType   -> Charset
  void __fastcall _fFontNameSizeFromLangType(void); //LangType   -> FontName & FontSize

  LANGID        _SysLangId;
  TLangType     _LangType;

  TVictorString _FontName;
  TFontCharset  _Charset;
  int           _FontSize;

  TDetectType   _DetectType;
  bool          _bTransBig5;

  enum CHINESE_CONSTANTS { GBK_COUNT = 24066 };
  static const CHINESE_CHAR GB2BIG5_TAB[GBK_COUNT];

  static const char Str_SongTi[];
  static const char Str_SimSun[];
  static const char Str_XiMyTi [];
  static const char Str_MingLiU[];
  static const char Str_MsSansSerif[];

  static const char Str_ParadoxAscii[];
  static const char Str_ParadoxGbk  [];
  static const char Str_ParadoxBig5 [];
};
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------------
class PACKAGE DateX
{
public:
  inline DateX()                              { Today();                  }
  inline DateX(TDateTime x)                   { Assign(x);                }
  inline DateX(long Year, int Month, int Day) { Assign(Year, Month, Day); }

  inline void Today(void) { Assign(::Date()); }
  void NextMonth(int m=1);

  void Assign(TDateTime x);
  void Assign(long Year, int Month, int Day);

  __property int  Month = { read = _Month   , write = SetMonth }; //Month
  __property int  Day   = { read = _Day     , write = SetDay   }; //Day
  __property int  Year  = { read = GetYear  , write = SetYear  }; //Year
  __property long YearL = { read = _Year    , write = SetYearL }; //Year
  __property long D111  = { read = _lDays111, write = SetD111  }; //Days from 01/01/0001
  __property int  DOW   = { read = _DOW       }; //Day of Week, 0:Sun, 1:Mon ... , 6:Sat

  __property int  MonthDays = { read = GetMonthDays };
  __property bool IsLeap    = { read = _isLeap      };
  __property bool IsValid   = { read = _isValid     };

  inline operator TDate() { return EncodeDate(Year,Month,Day); }

  inline DateX operator ++(int)    { DateX td(*this); D111++; return td; } //日期 = 日期++
  inline DateX operator --(int)    { DateX td(*this); D111--; return td; } //日期 = 日期--
  inline DateX operator ++()       { D111++; return *this;  } //日期 = ++日期
  inline DateX operator --()       { D111--; return *this;  } //日期 = --日期

  inline DateX operator +=(long L) { D111+=L; return *this; } //日期 = 日期 += 天数
  inline DateX operator -=(long L) { D111-=L; return *this; } //日期 = 日期 -= 天数

  inline DateX operator +(int   i) { DateX td(*this); td.D111+=i; return td; } //日期 = 日期 + 天数
  inline DateX operator -(int   i) { DateX td(*this); td.D111-=i; return td; } //日期 = 日期 - 天数
  inline int   operator -(DateX d) { return D111 - d.D111;                   } //天数 = 日期 - 日期

  inline bool  operator > (DateX d) { return D111 >  d.D111; }
  inline bool  operator < (DateX d) { return D111 <  d.D111; }
  inline bool  operator >=(DateX d) { return D111 >= d.D111; }
  inline bool  operator <=(DateX d) { return D111 <= d.D111; }
  inline bool  operator ==(DateX d) { return D111 == d.D111; }
  inline bool  operator !=(DateX d) { return D111 != d.D111; }

  int        GetMonthDays(int Month);
  inline int GetMonthDays(void)  { return GetMonthDays(_Month); }

private:
  inline int  GetYear(void)      { return (int) _Year;          }
  inline void SetMonth(int m)    { Assign(_Year,      m, _Day); }
  inline void SetDay(int d)      { Assign(_Year, _Month,    d); }
  inline void SetYear(int y)     { Assign(    y, _Month, _Day); }
  inline void SetYearL(long y)   { Assign(    y, _Month, _Day); }

  bool _isLeap(void);
  bool _isValid(void);

  void SetD111(long d);  // Assign Days from 1-1-1
  void AssignDOW(void);  // Assign Day of Week
  void DateToY111(void); // _Year, _Month, _Day --> _Days111
  void Y111ToDate(void); // _Days111 --> _Year, _Month, _Day

  int  _DOW, _Month, _Day;
  long _Year, _lDays111;

  static const int _MonthDays[12];
};
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------------
class PACKAGE TimeX
{
public:
  inline TimeX()                                 { Now();                        }
  inline TimeX(TDateTime x)                      { Assign(x);                    }
  inline TimeX(int Hour, int Minute, int Second) { Assign(Hour, Minute, Second); }

  inline void Now(void) { Assign(::Time()); }

  void Assign(TDateTime x);
  void Assign(int Hour, int Minute, int Second);

  __property int  Hour   = { read = _Hour       , write = SetHour    };
  __property int  Minute = { read = _Minute     , write = SetMinute  };
  __property int  Second = { read = _Second     , write = SetSecond  };
  __property long S000   = { read = _lSeconds000, write = SetSecs000 };

  __property bool IsValid = { read = _isValid };

  inline operator TTime() { return EncodeTime(Hour,Minute,Second,0); }

  inline TimeX operator ++(int)    { TimeX tt(*this); S000++; return tt; }
  inline TimeX operator --(int)    { TimeX tt(*this); S000--; return tt; }
  inline TimeX operator ++()       { S000++; return *this;  }
  inline TimeX operator --()       { S000--; return *this;  }

  inline TimeX operator +=(long L) { S000+=L; return *this; }
  inline TimeX operator -=(long L) { S000-=L; return *this; }

  inline TimeX operator +(int   i) { TimeX tt(*this); tt.S000+=i; return tt; }
  inline TimeX operator -(int   i) { TimeX tt(*this); tt.S000-=i; return tt; }
  inline int   operator -(TimeX t) { return S000 - t.S000;                   }

  inline bool  operator > (TimeX t) { return S000 >  t.S000; }
  inline bool  operator < (TimeX t) { return S000 <  t.S000; }
  inline bool  operator >=(TimeX t) { return S000 >= t.S000; }
  inline bool  operator <=(TimeX t) { return S000 <= t.S000; }
  inline bool  operator ==(TimeX t) { return S000 == t.S000; }
  inline bool  operator !=(TimeX t) { return S000 != t.S000; }

private:
  inline void SetHour(int h)     { Assign(    h, _Minute, _Second); }
  inline void SetMinute(int m)   { Assign(_Hour,       m, _Second); }
  inline void SetSecond(int s)   { Assign(_Hour, _Minute,       s); }

  void SetSecs000(long);
  void TimeToT000(void);
  void T000ToTime(void);
  bool _isValid(void);

  int  _Hour, _Minute, _Second;
  long _lSeconds000;
};
//---------------------------------------------------------------------------
/////////////////////////////////////////////////////////////////////////////
//---------------------------------------------------------------------------
class PACKAGE DateTimeX
{
public:
  inline DateTimeX()                                         { /* current time */   }
  inline DateTimeX(__int64 i)                                { Assign(i);           }
  inline DateTimeX(TDateTime x)                              { Assign(x);           }
  inline DateTimeX(DateX d, TimeX t)                         { Assign(d,t);         }
  inline DateTimeX(int y, int m, int d, int h, int n, int s) { Assign(y,m,d,h,n,s); }

  inline void Now(void) { Assign(::Now()); }
  inline void NextMonth(int m=1) { _xDate.NextMonth(m); }

  void Assign(__int64 i);
  void Assign(TDateTime x);
  void Assign(DateX d, TimeX t);
  void Assign(int y, int m, int d, int h, int n, int s);

  __property int Month  = { read = fGetMonth , write = fSetMonth };
  __property int Day    = { read = fGetDay   , write = fSetDay   };
  __property int Year   = { read = fGetYear  , write = fSetYear  };
  __property int Hour   = { read = fGetHour  , write = fSetHour  };
  __property int Minute = { read = fGetMinute, write = fSetMinute};
  __property int Second = { read = fGetSecond, write = fSetSecond};
  __property int DOW    = { read = fGetDOW  }; //day of week