mi32/mijob.h

Go to the documentation of this file.

/******************************************************************************
 *
 * \file mi32/mijob.h
 * \brief MIJOB
 *
 * \if NODOC
 * $Log: mijob.h_v $
 * Revision 1.30  2011/05/20 14:22:39  mju
 * Use proper inclusion guard naming convention.
 *
 * Revision 1.29  2011/05/19 21:14:13  bcolombe
 * Add ResolveTempJobs
 *
 * Revision 1.28  2011/04/29 16:43:34  bcolombe
 * Make CreateGroup static
 *
 * Revision 1.27  2011/04/06 22:06:06  bcolombe
 * Add GetPath
 *
 * Revision 1.26  2011/03/31 22:20:50  bcolombe
 * Create and Write group in single method
 *
 * Revision 1.25  2011/03/28 19:24:53  bcolombe
 * Add group support
 *
 * Revision 1.24  2010/10/07 17:45:36  bcolombe
 * Add option to block if file exists or doesnt exist
 *
 * Revision 1.23  2010/04/23 20:51:08  mju
 * Add add/findBinary.
 *
 * Revision 1.22  2010/01/08 18:01:09  bcolombe
 * Add option for adding input/output that won't be checked for blocking issues
 *
 * Revision 1.21  2010/01/06 17:11:20  mju
 * Fix findEnum shadowing error.
 *
 * Revision 1.20  2010/01/06 15:47:47  mju
 * Add findEnum that returns xmlnode, and node parm to getEnum.
 *
 * Revision 1.19  2010/01/04 17:25:12  bcolombe
 * Default priority is now 5
 *
 * Revision 1.18  2009/06/22 16:29:37  bcolombe
 * Add char* value
 *
 * Revision 1.17  2009/06/22 14:16:52  bcolombe
 * Remove dlg_schedule from mijob
 *
 * Revision 1.16  2009/06/19 20:19:31  mju
 * Change statusmgr to pointer so not constructed until needed.
 * Don't include hdrs not explicitly needed, forward-declare classes instead.
 *
 * Revision 1.15  2009/06/19 14:01:12  mju
 * Add int/long variants of findValue.
 * Add template methods for getEnum/Defaulted and getValueDefaulted.
 *
 * Revision 1.14  2009/06/18 17:49:55  mju
 * Add setReady.
 *
 * Revision 1.13  2009/06/18 17:40:16  bcolombe
 * Add ability to write scheduled job directly
 *
 * Revision 1.12  2009/06/18 16:13:47  mju
 * Add addInput/OutputPath variants using filepath.
 *
 * Revision 1.11  2009/06/17 17:42:52  bcolombe
 * Added changed for scheduled jobs
 *
 * Revision 1.10  2009/05/01 14:38:32  mju
 * Add findPath variant using FILEPATH.
 *
 * Revision 1.9  2009/04/30 22:49:37  bcolombe
 * Make destruc. virtual and exclude private members from doxygen
 *
 * Revision 1.8  2009/02/12 22:51:32  bcolombe
 * Enable job status on mac
 *
 * Revision 1.7  2009/02/04 23:11:12  bcolombe
 * Disabled jobstatus on mac
 *
 * Revision 1.6  2009/01/23 19:36:18  bcolombe
 * Added way to read without starting up status reporting
 *
 * Revision 1.5  2009/01/23 18:57:51  bcolombe
 * Added job status
 *
 * Revision 1.4  2008/11/21 23:12:58  bcolombe
 * Add to write the ability to create as held
 *
 * Revision 1.3  2008/11/06 18:13:03  bcolombe
 * Added GetInput/OuputList, AddInput/OutputPath, FindPath
 *
 * Revision 1.2  2008/10/02 21:06:00  bcolombe
 * Added GetRunParmsNode
 *
 * Revision 1.1  2008/10/02 18:02:51  bcolombe
 * Initial revision
 *
 * \endif
*/
/*****************************************************************************/

#ifndef INC_MI32_MIJOB_H
#define INC_MI32_MIJOB_H

#ifndef INC_MI32_XML_H
#include <mi32/xml.h>
#endif

#ifndef INC_MI32_FILEPATH_H
#include <mi32/filepath.h>
#endif

class FILEPATHLIST;
class MIJOBSTATUS;
namespace RVC {
   class OBJITEM;
   }

class MIJOB {
   public:

      static ERRVALUE CreateGroup (
         const MISTRING& description,  
         MISTRING& GroupID,            
         INT32 priority = -1,       
         bool bCreateAsTemp = false    
         );

      static ERRVALUE CreateGroup (
         const FILEPATH& directory,    
         const MISTRING& description,  
         MISTRING& GroupID,            
         INT32 priority = -1,       
         bool bCreateAsTemp = false    
         );

      static ERRVALUE ResolveTempJobs (
         );

      MIJOB ();
      virtual ~MIJOB ();
      
      XMLNODE* AddBinary (
         const char *name,          
         const SIMPLE_ARRAY<UINT8>& data,
         XMLNODE *node = 0          
         );

      XMLNODE* AddNode (
         const char *name,          
         XMLNODE *node = 0       
         );

      XMLNODE* AddValue (
         const char *name,          
         const MISTRING& value,        
         XMLNODE *node = 0       
         );

      XMLNODE* AddValue (
         const char *name,          
         const char* value,            
         XMLNODE *node = 0          
         );

      XMLNODE* AddValue (
         const char *name,          
         UINT32 value,              
         XMLNODE *node = 0       
         );

      XMLNODE* AddValue (
         const char *name,          
         INT32 value,               
         XMLNODE *node = 0       
         );

      XMLNODE* AddValue (
         const char *name,          
         UINT16 value,              
         XMLNODE *node = 0       
         );

      XMLNODE* AddValue (
         const char *name,          
         INT16 value,               
         XMLNODE *node = 0       
         );

      XMLNODE* AddValue (
         const char *name,          
         UINT8 value,               
         XMLNODE *node = 0       
         );

      XMLNODE* AddValue (
         const char *name,          
         INT8 value,                
         XMLNODE *node = 0       
         );

      XMLNODE* AddValue (
         const char *name,          
         double value,              
         XMLNODE *node = 0       
         );

      XMLNODE* AddValue (
         const char *name,          
         bool value,                
         XMLNODE *node = 0       
         );

      XMLNODE* AddInputObject (
         const char* id,               
         const RVC::OBJITEM& objitem,  
         XMLNODE *node = 0,            
         bool IgnoreForBlocking = false,  
         bool BlockIfExist = false,    
         bool BlockIfNotExist = false  
         );

      XMLNODE* AddInputPath (
         const char* id,               
         const MISTRING& path,         
         XMLNODE *node = 0,            
         bool IgnoreForBlocking = false,  
         bool BlockIfExist = false,    
         bool BlockIfNotExist = false  
         );

      XMLNODE* AddInputPath (
         const char* id,               
         const char* path,          
         XMLNODE *node = 0,            
         bool IgnoreForBlocking = false,  
         bool BlockIfExist = false,    
         bool BlockIfNotExist = false  
         );

      XMLNODE* AddInputPath (
         const char* id,               
         const FILEPATH& path,         
         XMLNODE *node = 0,               
         bool IgnoreForBlocking = false,  
         bool BlockIfExist = false,    
         bool BlockIfNotExist = false  
         );

      XMLNODE* AddOutputObject (
         const char* id,               
         const RVC::OBJITEM& objitem,  
         XMLNODE *node = 0,            
         bool IgnoreForBlocking = false   
         );

      XMLNODE* AddOutputPath (
         const char* id,               
         const MISTRING& path,         
         XMLNODE *node = 0,            
         bool IgnoreForBlocking = false   
         );

      XMLNODE* AddOutputPath (
         const char* id,               
         const char* path,          
         XMLNODE *node = 0,            
         bool IgnoreForBlocking = false   
         );

      XMLNODE* AddOutputPath (
         const char* id,               
         const FILEPATH& path,         
         XMLNODE *node = 0,               
         bool IgnoreForBlocking = false   
         );

      ERRVALUE CreateJob (
         const MISTRING& description,  
         const MISTRING& process,      
         INT32 priority = -1           
         );

      XMLNODE* FindBinary (
         const char *name,             
         SIMPLE_ARRAY<UINT8>& data,    
         const XMLNODE *node = 0       
         ) const;

      template <typename _ENUMTYPE> XMLNODE* FindEnum (
         const char *name,          
         _ENUMTYPE& value,          
         const XMLNODE *node = 0    
         ) const { INT32 temp; XMLNODE *noderet = FindValue(name,temp,node); if (noderet != 0) value = static_cast<_ENUMTYPE>(temp); return (noderet); }

      XMLNODE* FindNode (
         const char *name,          
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindObject (
         const char* id,               
         RVC::OBJITEM& objitem,        
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindPath (
         const char* id,               
         MISTRING& pathstr,            
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindPath (
         const char* id,               
         FILEPATH& path,               
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,             
         MISTRING& value,              
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,             
         char*& value,              
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,             
         unsigned long& value,         
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,             
         long& value,                  
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,             
         unsigned int& value,          
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,             
         int& value,                   
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,             
         UINT16& value,                
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,             
         INT16& value,                 
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,             
         UINT8& value,                 
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,             
         INT8& value,                  
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,             
         double& value,                
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,             
         float& value,                 
         const XMLNODE *node = 0       
         ) const;

      XMLNODE* FindValue (
         const char *name,          
         bool& value,               
         const XMLNODE *node = 0    
         ) const;

      void GetDescription (
         MISTRING& desc             
         ) const;

      template <typename _ENUMTYPE> bool GetEnum (
         const char *name,          
         _ENUMTYPE& value,          
         const XMLNODE *node = 0    
         ) const { INT32 temp; if (FindValue(name,temp,node) == 0) return (false); value = static_cast<_ENUMTYPE>(temp); return (true); }

      template <typename _ENUMTYPE> _ENUMTYPE GetEnumDefaulted (
         const char *name,          
         _ENUMTYPE dft,             
         const XMLNODE *node = 0    
         ) const { INT32 temp; if (!FindValue(name,temp,node)) return (dft); else return (static_cast<_ENUMTYPE>(temp)); }

      void GetBlockingInputList (
         FILEPATHLIST& list
         ) const;

      void GetBlockingOutputList (
         FILEPATHLIST& list
         ) const;

      void GetBlockingIfExistList (
         FILEPATHLIST& list
         ) const;

      void GetBlockingIfNotExistList (
         FILEPATHLIST& list
         ) const;

      void GetGroupID (
         MISTRING& GroupID
         );

      void GetInputList (
         FILEPATHLIST& list
         ) const;

      void GetOutputList (
         FILEPATHLIST& list
         ) const;

      const FILEPATH& GetPath () const {return m_path;}

      INT32 GetPriority () const;

      void GetProcess (
         MISTRING& process          
         ) const;

      XMLNODE* GetRunParmsNode () {return m_runparmsnode;}

      XMLNODE* GetRootNode () {return m_rootnode;}

      template <typename _NUMTYPE> _NUMTYPE GetValueDefaulted (
         const char *name,          
         _NUMTYPE value             
         ) const { FindValue(name,value); return (value); }

      bool IsTimeToRun();

      bool IsVersionMatch();

      ERRVALUE ReadJob (
         const FILEPATH& path       
         );

      ERRVALUE ReadJobNoStatus (
         const FILEPATH& path       
         );

      bool SetGroupID (
         const MISTRING& GroupID       
         );

      ERRVALUE SetNextTime ();

      void SetReady (
         ) { m_IsJobRead = true; }

      ERRVALUE Write (
         bool held = false,            
         FILEPATH* path = 0,           
         bool bCreateAsTemp = false    
         );

      ERRVALUE Write (
         const FILEPATH& directory,    
         bool held = false,            
         FILEPATH* path = 0,           
         bool bCreateAsTemp = false    
         );

      ERRVALUE WriteScheduled (
         FILEPATH* path = 0            
         );

      ERRVALUE WriteDoc () {return m_doc.Write(m_path);}

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      bool m_IsJobRead;
      XMLDOC m_doc;
      XMLNODE *m_rootnode;
      XMLNODE *m_runparmsnode;
      MIJOBSTATUS *m_pStatusMgr;
      FILEPATH m_path;

      XMLNODE *FindValueNode (const char *name, const XMLNODE *node) const;
      #endif
   };

#endif      //  INC_MI32_MIJOB_H

---