SourceForge.jp

dkutilDefined.h

説明を見る。
00001 
00002 
00008 #ifndef _dkutil_Defined__
00009 #define _dkutil_Defined__
00010 
00011 #include "dkutilDefinedC.h"
00012 #include "dKingyoMacro.h"
00013 #include "dkutilOutput.h"
00014 
00015 
00016 namespace dkutil{
00017 
00018 
00019 #if _MSC_VER >= 1000
00020 #   pragma warning(disable:4800)//boolに強制変換できないからって文句言わんどいてくれぃ!
00021 #endif
00022 inline bool isLittleEndian(){
00023     int x=1;
00024     return static_cast<bool>((*(char*)&x));
00025 }
00026 
00027 inline bool isBigEndian(){
00028     return (!isLittleEndian());
00029 }
00030 #if _MSC_VER >= 1000
00031 #pragma warning(default:4800)
00032 #endif
00033 
00034 //**********************************************************
00035 //抽象クラス
00036 //**********************************************************
00037 
00038 
00039 
00040 
00041 template<class V,class K>
00042 class IdKingyoDataWrapper{
00043 public:
00044     IdKingyoDataWrapper(){}
00045     virtual ~IdKingyoDataWrapper(){}
00046     virtual V GetData(K) = 0;
00047     virtual bool SetData(K,V) = 0;
00048     virtual bool DeleteDataByKey(K) = 0;
00049     virtual bool DeleteDataByValue(V) =0;
00050 };
00051 
00052 
00053 //乱数生成用
00054 
00055 
00056 template<typename T>
00057 class IdKingyoRandom{
00058 #ifdef _DEBUG
00059     public:
00060 #else
00061     protected:
00062 #endif
00063     unsigned long m_ulSeed;
00064     T m_Seed;
00065     T m_Max;
00066 public:
00067     IdKingyoRandom(){}
00068     virtual ~IdKingyoRandom(){}
00069     virtual T Rand() = 0;
00070     virtual T Random(T) = 0;
00071     virtual T RandomDomain(T min,T max) = 0;
00072     virtual T RandomDomainSafety(T min,T max) = 0;
00073     virtual T GetRandMax() = 0;
00074     virtual void SetSeed(T) = 0;
00075     virtual T MesBox(char *str,...) = 0;
00076 
00077 };
00078 
00079 
00080 //よく使うメンバ関数はすでに定義させておく
00081 template<typename T>
00082 class dKingyoRandom_BasicMember : public IdKingyoRandom<T>{
00083 public:
00084     dKingyoRandom_BasicMember(){}
00085     virtual ~dKingyoRandom_BasicMember(){}
00086     virtual T MesBox(char *str,...){
00087         char s[256];
00088         SET_VA_LIST(s,256,str);
00089         return (T) MessageBox(NULL,s,"DEBUG MESSAGE",MB_OK);
00090     }
00091     virtual T GetRandMax(){return m_Max;}
00092     virtual void SetSeed(T set){
00093         m_Seed = set;
00094         m_ulSeed=static_cast<ULONG>(m_Seed);
00095     }
00096 };
00097 
00098 extern bool SuperODS(const char *str,...);
00099 
00100 namespace private_{
00101 
00102     struct IntegerOrFloating{
00103     private:
00104         struct tugReserved{
00105             tugReserved(){all[0]=0;all[1]=0;}
00106             struct tugRFlag{
00108                 bool mD,mI,mLL,mULL;
00109                 bool Inserted;
00110             };
00111             union{
00112                 tugRFlag flag;
00113                 int all[2];
00114             };
00115             //2個分
00116             
00117         };
00118         tugReserved mR;
00119         void flush__(){mR.flag.mD=false;mR.flag.mI=false;mR.flag.mLL=false;mR.flag.mULL=false;}
00120         void construct_(){flush__();}
00121     public:
00122         IntegerOrFloating(){construct_();}
00123         IntegerOrFloating(int gi){construct_();i=gi;mR.flag.mI=true;}
00124         IntegerOrFloating(LONGLONG gll){construct_();ll=gll;mR.flag.mLL=true;}
00125         IntegerOrFloating(ULONGLONG gull){construct_();ull = gull;mR.flag.mULL=true;}
00126         IntegerOrFloating(float gf){construct_();d=gf;mR.flag.mD=true;}
00127         IntegerOrFloating(double gd){construct_();d=gd;mR.flag.mD=true;}
00128         /*IntegerOrFloating(const IntegerOrFloating &get){
00129             *this = get;
00130         }*/
00131         union {
00132             int i;
00133             LONGLONG ll;
00134             ULONGLONG ull;
00135             double d;
00136         };
00137         
00138         bool isDouble()const{return mR.flag.mD;}
00139         bool isInt()const{return mR.flag.mI;}
00140         bool isLongLong()const{return mR.flag.mLL;}
00141         bool isULongLong()const{return mR.flag.mULL;}
00142         bool empty()const{return isDouble() && isInt() && isLongLong() && isULongLong();}
00143         void insert(int ig){flush__();i=ig;mR.flag.mI=true;}
00144         void insert(LONGLONG llg){flush__();ll=llg;mR.flag.mLL=true;}
00145         void insert(ULONGLONG ullg){flush__();ull=ullg;mR.flag.mULL=true;}
00146         void insert(double dg){flush__();d=dg;mR.flag.mD=true;}
00147         bool print()const{
00148 
00149             if(isDouble()){
00150                 dkutil::SuperODS("%f",d);
00151             }else if(isInt()){
00152                 dkutil::SuperODS("%d",i);
00153             }else if(isLongLong()){
00154                 dkutil::SuperODS("%d",ll);
00155             }else if(isULongLong()){
00156                 dkutil::SuperODS("%d",ull);
00157             }else{
00158                 return false;
00159             }
00160             return true;
00161         }
00162 
00163 
00164     };
00165 
00166     template<typename T = IntegerOrFloating>
00167     struct GeneralPurposeVariable_Base : public T{
00168     public:
00169         std::string mstr;
00170         GeneralPurposeVariable_Base(const char *s){ mstr = s;}
00171         GeneralPurposeVariable_Base(const std::string &gs){mstr = gs;}
00172         GeneralPurposeVariable_Base(const int gi) : T(gi){}
00173         GeneralPurposeVariable_Base(const LONGLONG gll) : T(gll){}
00174         GeneralPurposeVariable_Base(const ULONGLONG gull) : T(gull){}
00175         GeneralPurposeVariable_Base(const float gf) : T(gf){}
00176         GeneralPurposeVariable_Base(const double gd) : T(gd){}
00177         GeneralPurposeVariable_Base() : T(){}
00178         /*GeneralPurposeVariable_Base(const GeneralPurposeVariable_Base<T> &get){
00179             *this = get;
00180         }*/
00181         bool isString()const{return !mstr.empty();}
00182         void insert(const char *s){mstr = s;}
00183         void insert(std::string s){mstr = s;}
00184         void insert(int ig){T::insert(ig);}
00185         void insert(LONGLONG llg){T::insert(llg);}
00186         void insert(ULONGLONG ullg){T::insert(ullg);}
00187         void insert(double dg){T::insert(dg);}
00188 
00189         bool empty()const{ return ( T::empty() && mstr.empty() );}
00191         bool print()const{
00192             if(isString()){
00193                 dkutil::SuperODS("%s",mstr.c_str());
00194             }else{
00195                 return T::print();
00196             }
00197             return true;
00198         }
00199         friend bool operator ==(const GeneralPurposeVariable_Base<T> &one,const char *str){
00200             if(!one.isString()) return false;
00201             return (one.mstr == str);
00202         }
00203         friend bool operator ==(const GeneralPurposeVariable_Base<T> &one,std::string str){
00204             if(!one.isString()) return false;
00205             return (one.mstr == str);
00206         }
00207                 friend bool operator ==(const GeneralPurposeVariable_Base<T> &one,int two){
00208             if(!one.isInt()) return false;
00209             return (one.i == two);
00210         }
00211         friend bool operator ==(const GeneralPurposeVariable_Base<T> &one,LONGLONG two){
00212             if(!one.isLongLong()) return false;
00213             return (one.ll == two);
00214         }
00215         friend bool operator ==(const GeneralPurposeVariable_Base<T> &one,ULONGLONG two){
00216             if(!one.isULongLong()) return false;
00217             return (one.ull == two);
00218         }
00219         friend bool operator ==(const GeneralPurposeVariable_Base<T> &one,double d){
00220             if(!one.isDouble()) return false;
00221             return (one.d == d);
00222         }
00223         friend bool operator !=(const GeneralPurposeVariable_Base<T> &one,double d){
00224             if(!one.isDouble()) return false;
00225             return (one.d != d);
00226         }
00227         
00245         bool double_inserted(bool your_detail)const{return isString() && your_detail;}
00246 
00247     };
00248 
00249 
00250 }//end of private_ namespace
00251 
00252 
00253 typedef private_::GeneralPurposeVariable_Base<> GeneralPurposeVariable;
00254 
00255 
00256 }//end of dkutil namespace
00257 
00258 #endif //end of include once

dkutil 1.02リリース前 d金魚専用マニュアルバージョンに対してSun Dec 28 21:23:07 2003に生成されました。 doxygen 1.3.5