0.6.x/js/core/05_XClass.js

   1 /**\r
   2  * Class を定義し システムの管理下に置く．\r
   3  * 全てのクラスと pool が有効の場合インスタンスへの参照が保持される．\r
   4  *  1. X.Class.create( def, opt_final, opt_pool, opt_abstract ) でクラスを登録．\r
   5  *  2. コンストラクタ となるメソッドは、Constructor : function( arg ){ ... }, に書く．\r
   6  *  3. 通常通り new で インスタンス生成\r
   7  *  4. kill() でオブジェクトをクリーンして削除、pool が有効の場合は pool される．\r
   8  *  5. pool が有効の場合、new で pool されたインスタンスが返される．\r
   9  *  6. \r
  10  * \r
  11  */\r
  12 X.Class = ( function(){\r
  13         var CLASS_LIST         = [],\r
  14                 DEF_LIST           = [],\r
  15                 PRIVATE_CLASS_LIST = [],\r
  16                 PRIVATE_DEF_LIST   = [],\r
  17                 CONSTRUCTOR        = 'Constructor',\r
  18                 killPrivateFlag    = false,\r
  19                 traits             = null,\r
  20                 _slice             = Array.prototype.slice;\r
  21                 \r
  22         function copyArray( list ){\r
  23         //return _slice.call( list, 0 );\r
  24         var i = list.length, ret = new Array( i );\r
  25         for( ; i; ){\r
  26                 ret[ --i ] = list[ i ];\r
  27         };\r
  28         return ret;\r
  29         };\r
  30         \r
  31         /* サブクラスを作るメソッド  \r
  32          * var subClass = superClass.inherits( ... ) \r
  33          * http://d.hatena.ne.jp/m-hiyama/20051018/1129605002\r
  34          */\r
  35         function inherits( /* displayName, classSetting, opt_PrivateClass, props */ ){\r
  36                 var args        = copyArray( arguments ),\r
  37                         params      = [],\r
  38                         Super       = this,\r
  39                         superDef    = X.Class._getClassDef( Super ),\r
  40                         displayName = args[ 0 ],\r
  41                         classSetting,\r
  42                         opt_super,\r
  43                         klass, def;\r
  44                 if( superDef.Final === true ) throw new Error( 'Class is final!' );\r
  45                 \r
  46                 if( X.Type.isString( displayName ) === true ){\r
  47                         args.shift();\r
  48                 } else {\r
  49                         displayName = 'SubClass of ' + superDef.displayName;\r
  50                 };\r
  51                 params.push( displayName );\r
  52                 \r
  53                 classSetting = args[ 0 ];\r
  54                 if( X.Type.isNumber( classSetting ) === true ){\r
  55                         if( superDef.isPrivate === true ) classSetting = classSetting | X.Class.PRIVATE_DATA;\r
  56                         opt_super = !!( classSetting & X.Class.SUPER_ACCESS );\r
  57                         params.push( classSetting );\r
  58                         args.shift();\r
  59                 };\r
  60                 if( X.Class._getClass( args[ 0 ] ) ){\r
  61                         params.push( args.shift() );\r
  62                 } else\r
  63                 if( superDef.privateClass ){\r
  64                         params.push( superDef.privateClass );\r
  65                 };\r
  66                 params.push( args[ 0 ] ); /* props */\r
  67                 Super.__new = null;\r
  68                 traits = new Super();\r
  69                 Super.__new = C;\r
  70                 klass  = X.Class.create.apply( null, params );\r
  71                 traits = null;\r
  72                 if( opt_super === true ){\r
  73                         def = X.Class._getClassDef( klass );\r
  74                         def.Super = Super.prototype;\r
  75                         def.SuperConstructor = superDef[ CONSTRUCTOR ];\r
  76                 };\r
  77                 return klass;\r
  78         };\r
  79         \r
  80         /* X.Class.create で作られたクラスのインスタンスが共通で備えるメソッド */\r
  81         var CommonProps = {\r
  82                 kill : function(){\r
  83                         var instance = this,\r
  84                                 klass    = X.Class._getClass( instance ),\r
  85                                 def      = X.Class._getClassDef( klass ),\r
  86                                 data, p, i;\r
  87                         if( def.isPrivate === true && killPrivateFlag === false ){\r
  88                                 throw new Error( 'PrivateInstance.kill() work in PrivateUser.kill().' );\r
  89                         };\r
  90                         killPrivateFlag = false; // onKill 内で PrivateInstance.kill() を防ぐため\r
  91                         X.Type.isFunction( instance.onKill ) === true && instance.onKill();\r
  92                         for( p in instance ){\r
  93                                 if( instance.hasOwnProperty && !instance.hasOwnProperty( p ) ) continue;\r
  94                                 delete instance[ p ];\r
  95                         };\r
  96                         if( def.pool ){\r
  97                                 def.live && def.live.splice( def.live.indexOf( instance ), 1 );\r
  98                                 def.pool[ def.pool.length ] = instance;\r
  99                         };\r
 100                         if( def.privateClass ){\r
 101                                 i = def.userList.indexOf( instance );\r
 102                                 if( i !== -1 ){\r
 103                                         data            = X.Class._getPrivate( instance );\r
 104                                         killPrivateFlag = true;\r
 105                                         data.kill();\r
 106                                         def.dataList.splice( i, 1 );\r
 107                                         def.userList.splice( i, 1 );\r
 108                                 };\r
 109                         };\r
 110                         // myCallback の削除\r
 111                         // myCallback を受け取った API への通知\r
 112                 }\r
 113         };\r
 114         \r
 115         /*\r
 116          * new の実体．コンストラクタの機能は instance.Constructor に書く．\r
 117          * これにより pool された オブジェクト（破棄されたインスタンス） を再利用できる\r
 118          */\r
 119         /* Constructor Real for GeneralClass */\r
 120         function C( args ){\r
 121                 var klass    = this,\r
 122                         def      = X.Class._getClassDef( klass ),\r
 123                         dataUser = def._tempUser,\r
 124                         instance,\r
 125                         userDef;\r
 126                 if( def.Abstract === true ){\r
 127                         throw new Error( 'AbstractClass!' );\r
 128                 };\r
 129                 if( def.isPrivate === true && dataUser === null ){\r
 130                         throw new Error( 'use myClass.newPrivate( instance, ...args )!' );\r
 131                 };\r
 132                 klass.__new = null;\r
 133                 instance = def.pool && def.pool.length > 0 ? def.pool.pop() : new klass();\r
 134                 klass.__new = C;\r
 135                 if( def.isPrivate === true ){\r
 136                         userDef = X.Class._getClassDef( dataUser );\r
 137                         userDef.dataList.push( instance );\r
 138                         userDef.userList.push( dataUser );\r
 139                         instance.User = dataUser;\r
 140                         def._tempUser = null;\r
 141                 } else {\r
 142                         def.live && def.live.push( instance );\r
 143                 };\r
 144                 if( def.Super ){\r
 145                         instance.Super = def.Super;\r
 146                         instance.SuperConstructor = superConstructor;\r
 147                 };\r
 148                 def[ CONSTRUCTOR ] && def[ CONSTRUCTOR ].apply( instance, args );\r
 149                 return instance;\r
 150         };\r
 151         \r
 152         function superConstructor(){\r
 153                 X.Class._getClassDef( this ).SuperConstructor.apply( this, arguments );\r
 154         };\r
 155         \r
 156         return {\r
 157                 POOL_OBJECT  : 1,\r
 158                 ABSTRACT     : 2,\r
 159                 FINAL        : 4,\r
 160                 SUPER_ACCESS : 8,\r
 161                 PRIVATE_DATA : 16,\r
 162                 create : function( /* displayName, classSetting, opt_PrivateClass, props */ ){\r
 163                         var args        = copyArray( arguments ),\r
 164                                 displayName = args[ 0 ],\r
 165                                 classSetting,\r
 166                                 opt_pool, opt_abstract, opt_final, opt_private,\r
 167                                 privateDef,\r
 168                                 props,\r
 169                                 klass,\r
 170                                 classDef = {};\r
 171                         if( X.Type.isString( displayName ) === true ){\r
 172                                 classDef.displayName = displayName;\r
 173                                 args.shift();\r
 174                         };\r
 175                         classSetting = args[ 0 ];\r
 176                         if( X.Type.isNumber( classSetting ) === true ){\r
 177                                 opt_pool     = !!( classSetting & X.Class.POOL_OBJECT  );\r
 178                                 opt_abstract = !!( classSetting & X.Class.ABSTRACT     );\r
 179                                 opt_final    = !!( classSetting & X.Class.FINAL        );\r
 180                                 opt_private  = !!( classSetting & X.Class.PRIVATE_DATA );\r
 181                                 if( opt_final === true && opt_abstract === true ){\r
 182                                         throw new Error( 'final & Abstract!' );\r
 183                                 };                              \r
 184                                 args.shift();\r
 185                         };\r
 186                         \r
 187                         if( PRIVATE_CLASS_LIST.indexOf( args[ 0 ] ) !== -1 ){\r
 188                                 privateDef = X.Class._getClassDef( args[ 0 ] );\r
 189                                 if( privateDef.isPrivate !== true ){\r
 190                                         throw new Error( 'PrivateClass not found! please, X.Class.create( X.Class.PRIVATE, {...} ).' );\r
 191                                 } else\r
 192                                 if( privateDef.Abstract === true ){\r
 193                                         throw new Error( 'PrivateClass is Abstract!' );\r
 194                                 };\r
 195                                 classDef.privateClass = args.shift();\r
 196                         };\r
 197                         props = args[ 0 ];\r
 198                         if( props === null || X.Type.isObject( props ) === false ){\r
 199                                 throw new Error( 'No Class Def!' );\r
 200                         };\r
 201                         \r
 202                         if( X.Type.isFunction( props[ CONSTRUCTOR ] ) === true ){\r
 203                                 classDef[ CONSTRUCTOR ] = props[ CONSTRUCTOR ];\r
 204                         };\r
 205                         \r
 206                         klass = new Function( 'var a=arguments,f=a.callee;if(f.__new)return f.__new(a)' );\r
 207                         klass.__new = C;\r
 208                         klass.prototype = X.Class._override( X.Class._override( traits || klass.prototype, props, true ), CommonProps, false );\r
 209                         klass.name = displayName;\r
 210                         \r
 211                         if( opt_abstract === true ){\r
 212                                 classDef.Abstract = true;\r
 213                         } else\r
 214                         if( opt_pool === true ){\r
 215                                 classDef.pool = [];\r
 216                                 if( opt_private === false ) classDef.live = [];\r
 217                         };                      \r
 218                         if( opt_final === true ){\r
 219                                 classDef.Final = true;\r
 220                         } else {\r
 221                                 klass.inherits = inherits;\r
 222                         };                      \r
 223                         if( opt_private === true ){\r
 224                                 if( classDef.privateClass ){\r
 225                                         throw new Error( 'Private Data Class has no PrivateClass!' );\r
 226                                 };\r
 227                                 classDef.isPrivate = true;\r
 228                                 PRIVATE_CLASS_LIST.push( klass );\r
 229                                 PRIVATE_DEF_LIST.push( classDef );\r
 230                         } else {\r
 231                                 CLASS_LIST.push( klass );\r
 232                                 DEF_LIST.push( classDef );                              \r
 233                         };\r
 234                         return klass;\r
 235                 },\r
 236                 sys_shutdown : function(){\r
 237                         \r
 238                 },\r
 239                 _getClass : function( instance ){\r
 240                         var cList    = CLASS_LIST,\r
 241                                 i        = cList.length,\r
 242                                 klass;\r
 243                         for( ; i; ){\r
 244                                 klass = cList[ --i ];\r
 245                                 if( instance instanceof klass ) return klass;\r
 246                         };\r
 247                         cList = PRIVATE_CLASS_LIST;\r
 248                         i     = cList.length;\r
 249                         for( ; i; ){\r
 250                                 klass = cList[ --i ];\r
 251                                 if( instance instanceof klass ) return klass;\r
 252                         };\r
 253                         \r
 254                         if( cList.indexOf( instance ) !== -1 ) return instance;\r
 255                         if( CLASS_LIST.indexOf( instance ) !== -1 ) return instance;\r
 256                 },\r
 257                 _getClassDef : function( KlassOrInstance ){\r
 258                         var i = CLASS_LIST.indexOf( KlassOrInstance );\r
 259                         if( i === -1 ) i = CLASS_LIST.indexOf( X.Class._getClass( KlassOrInstance ) );\r
 260                         if( i !== -1 ) return DEF_LIST[ i ];\r
 261                         \r
 262                         i = PRIVATE_CLASS_LIST.indexOf( KlassOrInstance );\r
 263                         if( i === -1 ) i = PRIVATE_CLASS_LIST.indexOf( X.Class._getClass( KlassOrInstance ) );\r
 264                         if( i !== -1 ) return PRIVATE_DEF_LIST[ i ];\r
 265                         \r
 266                         if( DEF_LIST.indexOf( KlassOrInstance ) !== -1 ) return KlassOrInstance;\r
 267                         if( PRIVATE_DEF_LIST.indexOf( KlassOrInstance ) !== -1 ) return KlassOrInstance;\r
 268                 },\r
 269                 _newPrivate : function( /* instance, args */ ){\r
 270                         var args         = copyArray( arguments ),\r
 271                                 user         = args.shift(),\r
 272                                 def          = X.Class._getClassDef( user ),\r
 273                                 privateClass = def.privateClass,\r
 274                                 privateDef   = X.Class._getClassDef( privateClass ),\r
 275                                 i            = -1;\r
 276                         if( def.userList ){\r
 277                                 i = def.userList.indexOf( user );\r
 278                         } else {\r
 279                                 def.userList = [];\r
 280                                 def.dataList = [];\r
 281                         };\r
 282                         if( i !== -1 ){\r
 283                                 throw new Error( 'PrivateData already exist!' );\r
 284                         };\r
 285                         if( privateDef._tempUser ){\r
 286                                 throw new Error( 'newPrivate を連続呼び出しされたところ破綻' );\r
 287                         };\r
 288                         privateDef._tempUser = user;\r
 289                         return privateClass.__new( args );\r
 290                 },\r
 291                 _getPrivate : function( instance ){\r
 292                         var def = X.Class._getClassDef( instance ),\r
 293                                 i   = def.userList.indexOf( instance );\r
 294                         if( i !== -1 ) return def.dataList[ i ];\r
 295                 },\r
 296                 /* over のプロパティを target にコピーする．ただし target の プロパティが優先, force で解除 */\r
 297                 _override : function ( target, src, force ){\r
 298                         for( var p in src ){\r
 299                                 if( p === 'Super' || p === 'SuperConstructor' ){\r
 300                                         throw new Error( 'Super & SuperConstructor is reserved!' );\r
 301                                 };\r
 302                                 if( force === true || target[ p ] === void 0 ){\r
 303                                         target[ p ] = src[ p ];\r
 304                                 };\r
 305                         };\r
 306                         return target;\r
 307                 }\r
 308         };\r
 309 })();