Miscellany

      package com.pixco.Codegen
      {
        import weborb.data.*;

        import mx.rpc.AsyncToken;
        import mx.rpc.Responder;
        import mx.rpc.events.ResultEvent;
        import mx.rpc.remoting.RemoteObject;

        import com.pixco.SecurityRule;
        import com.pixco.DataMapperRegistry;
      
        public dynamic class _SecurityRuleDataMapper extends DataMapper
        {
        
          public override function createActiveRecordInstance():ActiveRecord
          {
            return new SecurityRule();
          }
        
          protected override function get RemoteClassName():String
          {
            return "com.pixco.SecurityRuleDataMapper";
          }
          
      		public function load(securityRule:SecurityRule, responder:Responder = null):SecurityRule
          {
            
              if(!securityRule.IsPrimaryKeyInitialized)
          	    throw new Error("Record can be loaded only with initialized primary key");
          
              if(IdentityMap.exists(securityRule.getURI()))
              {
                securityRule = SecurityRule(IdentityMap.extract(securityRule.getURI()));
                
                if(securityRule.IsLoaded)
                  return securityRule;
      
              } 
              else
               IdentityMap.add(securityRule);
      
              var asyncToken:AsyncToken = new DatabaseAsyncToken(createRemoteObject().findByPrimaryKey(
                securityRule.ID),null,securityRule);
            
              return securityRule;
          }
          
      
          public function findByPrimaryKey(  iD:int):SecurityRule
          {
            var activeRecord:SecurityRule = new SecurityRule();

            
              activeRecord.ID = iD;
            



      return load(activeRecord);
      }

      public override function loadChildRelation(activeRecord:ActiveRecord,relationName:String, activeCollection:ActiveCollection):void
      {
        var item:SecurityRule = SecurityRule(activeRecord);
                   
        
              
              if(relationName == "relatedSecurityRuleSecurityRole")
              {
   
                DataMapperRegistry.Instance.SecurityRuleSecurityRole.
                findBySecurityRuleID(
                
                  item.ID, activeCollection)
              ;
                
                return;
              }
            
              
              if(relationName == "relatedSecurityRuleSecurityRight")
              {
   
                DataMapperRegistry.Instance.SecurityRuleSecurityRight.
                findBySecurityRuleID(
                
                  item.ID, activeCollection)
              ;
                
                return;
              }
            
              
              if(relationName == "relatedSecurityExpression")
              {
   
                DataMapperRegistry.Instance.SecurityExpression.
                findBySecurityRuleID(
                
                  item.ID, activeCollection)
              ;
                
                return;
              }
            
         }
        }
      }