Source/cmCommand.h

   1 /*=========================================================================
   2
   3   Program:   Insight Segmentation & Registration Toolkit
   4   Module:    $RCSfile: cmCommand.h,v $
   5   Language:  C++
   6   Date:      $Date: 2002-01-21 20:30:21 $
   7   Version:   $Revision: 1.11 $
   8
   9   Copyright (c) 2002 Insight Consortium. All rights reserved.
  10   See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17 #ifndef cmCommand_h
  18 #define cmCommand_h
  19
  20 #include "cmStandardIncludes.h"
  21 #include "cmMakefile.h"
  22
  23 /** \class cmCommand
  24  * \brief Superclass for all commands in CMake.
  25  *
  26  * cmCommand is the base class for all commands in CMake. A command
  27  * manifests as an entry in CMakeLists.txt and produces one or
  28  * more makefile rules. Commands are associated with a particular
  29  * makefile. This base class cmCommand defines the API for commands
  30  * to support such features as enable/disable, inheritance,
  31  * documentation, and construction.
  32  */
  33 class cmCommand
  34 {
  35 public:
  36   /**
  37    * Construct the command. By default it is enabled with no makefile.
  38    */
  39   cmCommand()
  40     {m_Makefile = 0; m_Enabled = true;}
  41
  42   /**
  43    * Need virtual destructor to destroy real command type.
  44    */
  45   virtual ~cmCommand() {}
  46
  47   /**
  48    * Specify the makefile.
  49    */
  50   void SetMakefile(cmMakefile*m)
  51     {m_Makefile = m; }
  52
  53   /**
  54    * This is called when the command is first encountered in
  55    * the CMakeLists.txt file.
  56    */
  57   virtual bool InitialPass(std::vector<std::string> const& args) = 0;
  58
  59   /**
  60    * This is called at the end after all the information
  61    * specified by the command is accumulated. Most commands do
  62    * not implement this method.  At this point, reading and
  63    * writing to the cache can be done.
  64    */
  65   virtual void FinalPass() {};
  66
  67   /**
  68    * This is a virtual constructor for the command.
  69    */
  70   virtual cmCommand* Clone() = 0;
  71
  72   /**
  73    * This determines if the command gets propagated down
  74    * to makefiles located in subdirectories.
  75    */
  76   virtual bool IsInherited()
  77     {
  78     return false;
  79     }
  80
  81   /**
  82    * The name of the command as specified in CMakeList.txt.
  83    */
  84   virtual const char* GetName() = 0;
  85
  86   /**
  87    * Succinct documentation.
  88    */
  89   virtual const char* GetTerseDocumentation() = 0;
  90
  91   /**
  92    * More documentation.
  93    */
  94   virtual const char* GetFullDocumentation() = 0;
  95
  96   /**
  97    * Enable the command.
  98    */
  99   void EnabledOn()
 100     {m_Enabled = true;}
 101
 102   /**
 103    * Disable the command.
 104    */
 105   void EnabledOff()
 106     {m_Enabled = false;}
 107
 108   /**
 109    * Query whether the command is enabled.
 110    */
 111   bool GetEnabled()
 112     {return m_Enabled;}
 113
 114   /**
 115    * Disable or enable the command.
 116    */
 117   void SetEnabled(bool enabled)
 118     {m_Enabled = enabled;}
 119
 120   /**
 121    * Return the last error string.
 122    */
 123   const char* GetError()
 124     {
 125       if(m_Error.length() == 0)
 126         {
 127         m_Error = this->GetName();
 128         m_Error += " unknown error.";
 129         }
 130       return m_Error.c_str();
 131     }
 132
 133   /**
 134    * Returns true if this class is the given class, or a subclass of it.
 135    */
 136   static bool IsTypeOf(const char *type)
 137     { return !strcmp("cmCommand", type); }
 138
 139   /**
 140    * Returns true if this object is an instance of the given class or
 141    * a subclass of it.
 142    */
 143   virtual bool IsA(const char *type)
 144     { return cmCommand::IsTypeOf(type); }
 145
 146 protected:
 147   void SetError(const char* e)
 148     {
 149     m_Error = this->GetName();
 150     m_Error += " ";
 151     m_Error += e;
 152     }
 153   cmMakefile* m_Makefile;
 154
 155 private:
 156   bool m_Enabled;
 157   std::string m_Error;
 158 };
 159
 160 // All subclasses of cmCommand should invoke this macro.
 161 #define cmTypeMacro(thisClass,superclass) \
 162 static bool IsTypeOf(const char *type) \
 163 { \
 164   if ( !strcmp(#thisClass,type) ) \
 165     { \
 166     return true; \
 167     } \
 168   return superclass::IsTypeOf(type); \
 169 } \
 170 virtual bool IsA(const char *type) \
 171 { \
 172   return thisClass::IsTypeOf(type); \
 173 } \
 174 static thisClass* SafeDownCast(cmCommand *c) \
 175 { \
 176   if ( c && c->IsA(#thisClass) ) \
 177     { \
 178     return (thisClass *)c; \
 179     } \
 180   return 0;\
 181 }
 182
 183
 184 #endif