at*mineer
Follow us on Twitter

Doxygen Documentation Comment Examples

Below are a number of examples of the automatic documentation generated by Atomineer in its default configuration (apart from switching to Doxygen mode).
These are exactly as generated by Atomineer, without any human intervention.

////////////////////////////////////////////////////////////////////////////////////////////////////
// \file    Examples\AtomineerExamplesDoxygen.cs
//
// \brief   Implements the atomineer utils examples doxygen class
////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////////////////////////
// namespace: Test
//
// summary:   .
////////////////////////////////////////////////////////////////////////////////////////////////////

namespace Test
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \interface  IDisposable
    ///
    /// \brief  Interface for objects that provide custom disposal implementations. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    [SomethingAttribute]
    public interface IDisposable
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  CommsErrorEventArgs
    ///
    /// \brief  Additional information for communications error events. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    [AnotherAttribute]
    internal class CommsErrorEventArgs : EventArgs
    {
    } 

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  CustomInfoAttr
    ///
    /// \brief  Attribute for custom information. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    protected class CustomInfoAttr
    {
    }

      ////////////////////////////////////////////////////////////////////////////////////////////////////
      /// \class    ObjEditorAttribute
      ///
      /// \brief    Attribute for object editor. 
      ///
      /// \author   Jason
      /// \date 21/01/2010
      ////////////////////////////////////////////////////////////////////////////////////////////////////

      public class ObjEditorAttribute
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  DataTblForm
    ///
    /// \brief  Form for viewing the data table. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class DataTblForm : Form
    {        
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  PrefsDlg
    ///
    /// \brief  Dialog for setting the preferences. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class PrefsDlg : Form
    {        
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  ErrorDialog
    ///
    /// \brief  Dialog for reporting errors to the user. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class ErrorDialog : Form
    {        
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  CreateNewItemWizard
    ///
    /// \brief  Wizard for creating new items. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class CreateNewItemWizard : Form
    {        
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  PantsOnFireException
    ///
    /// \brief  Exception for signalling pants on fire errors. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class PantsOnFireException : ArgumentNullException
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  BigExplosionEventArgs
    ///
    /// \brief  Additional information for big explosion events. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    internal class BigExplosionEventArgs
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  PlayingCardCollection
    ///
    /// \brief  Collection of playing cards. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public abstract class PlayingCardCollection
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  WndHandleColl
    ///
    /// \brief  Collection of window handles. 
    ///
    /// \author Jason
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public abstract class WndHandleColl
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  WndPtrList
    ///
    /// \brief  List of window pointers. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    internal class WndPtrList
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  SerialCommsBuffer
    ///
    /// \brief  Buffer for serial communications. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class SerialCommsBuffer
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  UserInfo
    ///
    /// \brief  Information about the user. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class UserInfo
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// \class  TestClass
    ///
    /// \brief  Test class. 
    ///
    /// \author Jason Williams
    /// \date   21/01/2010
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class TestClass
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn protected abstract JetPlane(string manufacturerNames, string modelName)
        ///
        /// \brief  Constructor. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  manufacturerNames   List of names of the manufacturers. 
        /// \param  modelName           Name of the model. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        protected abstract JetPlane(string manufacturerNames, string modelName)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn bool AutoParamGenTest(int numItems, int numberOfBlocks, string configFilename,
        ///     JobTypeEnum jobType, OptsEnum parseOptions, List<int> UserIdList, Colour fgColour,
        ///     int widthOfWingsInCm, int listSize, int listItemCount, int listLength, int rectWidth,
        ///     int circleHeight, byte *serialIOBuff, Manager &fileDataMgr, Context parseCtx,
        ///     ref string userInfo, out byte RAIDArrayID, UniqueIDSet programIds)
        ///
        /// \brief  Tests automatic parameter generation. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  numItems                Number of items. 
        /// \param  numberOfBlocks          Number of blocks. 
        /// \param  configFilename          Filename of the configuration file. 
        /// \param  jobType                 Type of the job. 
        /// \param  parseOptions            Options for controlling the parse. 
        /// \param  UserIdList              List of user identifiers. 
        /// \param  fgColour                The foreground colour. 
        /// \param  widthOfWingsInCm        Width of the wings in centimetres. 
        /// \param  listSize                Size of the list. 
        /// \param  listItemCount           Number of list items. 
        /// \param  listLength              Length of the list. 
        /// \param  rectWidth               Width of the rectangle. 
        /// \param  circleHeight            Height of the circle. 
        /// \param [in,out] serialIOBuff    If non-null, buffer for serial i/o data. 
        /// \param [in,out] fileDataMgr     Manager for file data. 
        /// \param  parseCtx                Context for the parse. 
        /// \param [in,out] userInfo        Information describing the user. 
        /// \param [out]    RAIDArrayID     Identifier for the raid array. 
        /// \param  programIds              List of identifiers for the programs. 
        ///
        /// \return true if the test passes, false if the test fails. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool AutoParamGenTest(int numItems, int numberOfBlocks,
                            string configFilename, JobTypeEnum jobType,
                            OptsEnum parseOptions, List<int> UserIdList,
                            Colour fgColour, int widthOfWingsInCm, int listSize,
                            int listItemCount, int listLength,
                            int rectWidth, int circleHeight,
                            byte *serialIOBuff, Manager &fileDataMgr,
                            Context parseCtx, ref string userInfo,
                            out byte RAIDArrayID, UniqueIDSet programIds)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn protected abstract void ParamAlignmentTest(int a, int ab, int abc, int abcd, int abcde,
        ///     int abcdef, int abcdefg, int abcdefgh, int abcdefghi, int abcdefghij, int abcdefghijk,
        ///     int abcdefghijkl, int abcdefghijklm, int abcdefghijklmn, int abcdefghijklmno,
        ///     int abcdefghijklmnop)
        ///
        /// \brief  Tests parameter alignment. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  a                   a. 
        /// \param  ab                  The ab. 
        /// \param  abc                 The abc. 
        /// \param  abcd                The abcd. 
        /// \param  abcde               The abcde. 
        /// \param  abcdef              The abcdef. 
        /// \param  abcdefg             The abcdefg. 
        /// \param  abcdefgh            The abcdefgh. 
        /// \param  abcdefghi           The abcdefghi. 
        /// \param  abcdefghij          The abcdefghij. 
        /// \param  abcdefghijk         The abcdefghijk. 
        /// \param  abcdefghijkl        The abcdefghijkl. 
        /// \param  abcdefghijklm       The abcdefghijklm. 
        /// \param  abcdefghijklmn      The abcdefghijklmn. 
        /// \param  abcdefghijklmno     The abcdefghijklmno. 
        /// \param  abcdefghijklmnop    The abcdefghijklmnop. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        protected abstract void ParamAlignmentTest(int a, int ab, int abc, int abcd,
                                    int abcde, int abcdef, int abcdefg, int abcdefgh,
                                    int abcdefghi, int abcdefghij, int abcdefghijk, int abcdefghijkl,
                                    int abcdefghijklm, int abcdefghijklmn, int abcdefghijklmno, int abcdefghijklmnop)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void Initialise()
        ///
        /// \brief  Initialises this object. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void Initialise()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void InitializeGradFill()
        ///
        /// \brief  Initializes the graduated fill. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void InitializeGradFill()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void InitFileBuffers()
        ///
        /// \brief  Initialises the file buffers. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void InitFileBuffers()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn private static void SetUpUninstaller(XmlElement settingsElem)
        ///
        /// \brief  Sets up the uninstaller. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  settingsElem    Element describing the settings. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void SetUpUninstaller(XmlElement settingsElem)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn static bool ExecuteAllChildInstallCommandsOf(XmlElement cmdRootElem)
        ///
        /// \brief  Execute all child install commands of the given command root element. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  cmdRootElem Element describing the command root. 
        ///
        /// \return true if it succeeds, false if it fails. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        static bool ExecuteAllChildInstallCommandsOf(XmlElement cmdRootElem)
        {
        }         

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void ConnectToBackupDataSvr()
        ///
        /// \brief  Connects to backup data server. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void ConnectToBackupDataSvr()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void TxDataToBackupSvr()
        ///
        /// \brief  Transmit data to backup server. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void TxDataToBackupSvr()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void DumpFlightInfo(out ClientList passengerManifest, ref int manifestSize)
        ///
        /// \brief  Dumps a flight information. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param [out]    passengerManifest   A list of passengers. 
        /// \param [in,out] manifestSize        Size of the manifest. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void DumpFlightInfo(out ClientList passengerManifest, ref int manifestSize)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn private static void ReportErrors()
        ///
        /// \brief  Reports the errors. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void ReportErrors()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn private static void ReportError(string format, params object[] args)
        ///
        /// \brief  Reports an error. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  format  Describes the format to use. 
        /// \param  args    A variable-length parameters list containing arguments. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void ReportError(string format, params object[] args)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn private static void WriteWarnings()
        ///
        /// \brief  Writes the warnings. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void WriteWarnings()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn private static void WriteWarning(string format, params object[] args)
        ///
        /// \brief  Writes a warning. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  format  Describes the format to use. 
        /// \param  args    A variable-length parameters list containing arguments. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void WriteWarning(string format, params object[] args)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn private static void WriteWarning(string report)
        ///
        /// \brief  Writes a warning. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  report  The report. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void WriteWarning(string report)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn private static void WriteWarning()
        ///
        /// \brief  Writes the warning. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void WriteWarning()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public bool Add(string text)
        ///
        /// \brief  Adds text.
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  text    The string to add. 
        ///
        /// \return true if it succeeds, false if it fails. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public bool Add(string text)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void AddNewItem(string item, List<string> itemList)
        ///
        /// \brief  Adds a new item to 'itemList'. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  item        The item. 
        /// \param  itemList    List of items. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void AddNewItem(string item, List<string> itemList)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void AddNewItem(string item)
        ///
        /// \brief  Adds a new item. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  item    The item. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void AddNewItem(string item)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void AppendEntry(int entry)
        ///
        /// \brief  Appends an entry. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  entry   The entry. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void AppendEntry(int entry)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void Append(string entry)
        ///
        /// \brief  Appends an entry. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  entry   The string to append. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void Append(string entry)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public Block AppendNewEntry(int entry)
        ///
        /// \brief  Appends a new entry. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  entry   The entry. 
        ///
        /// \return . 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public Block AppendNewEntry(int entry)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void AppendEntry(Block userData)
        ///
        /// \brief  Appends an entry. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  userData    Information describing the user. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void AppendEntry(Block userData)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void AppendEntry(Block userData, List<Block> entryList)
        ///
        /// \brief  Appends an entry. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  userData    Information describing the user. 
        /// \param  entryList   List of entries. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void AppendEntry(Block userData, List<Block> entryList)
        //! . 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void WriteEntry(string machineInfo)
        ///
        /// \brief  Writes an entry. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  machineInfo Information describing the machine. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void WriteEntry(string machineInfo)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void WriteEntry(string machineInfo, Stream outputStream)
        ///
        /// \brief  Writes an entry. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  machineInfo     Information describing the machine. 
        /// \param  outputStream    The output stream. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void WriteEntry(string machineInfo, Stream outputStream)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void Write(string machineInfo)
        ///
        /// \brief  Writes. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  machineInfo The string to write. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void Write(string machineInfo)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public delegate void NewGovernmentEventHandler(object sender, NewGovernmentEventArgs e)
        ///
        /// \brief  Delegate for handling NewGovernment events. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  sender  Source of the event. 
        /// \param  e       New government event information. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public delegate void NewGovernmentEventHandler(object sender, NewGovernmentEventArgs e);

        //! The military coup event
        public NewGovernmentEventHandler MilitaryCoupEvent;

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn protected virtual void OnMilitaryCoup(EventArgs e)
        ///
        /// \brief  Raises the military coup event. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  e   Event information to send to registered event handlers. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        protected virtual void OnMilitaryCoup(EventArgs e) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn protected virtual void RaiseMilitaryCoup(EventArgs e)
        ///
        /// \brief  Raises the military coup event. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  e   Event information to send to registered event handlers. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        protected virtual void RaiseMilitaryCoup(EventArgs e) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn void NewsListener_MilitaryCoupEvent(object sender, CoupEventArgs e)
        ///
        /// \brief  Event handler. Called by NewsListener for military coup events. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  sender  Source of the event. 
        /// \param  e       Coup event information. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        void NewsListener_MilitaryCoupEvent(object sender, CoupEventArgs e)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \property   public int ReadOnlyValue
        ///
        /// \brief  Gets the read only value. 
        ///
        /// \return The read only value. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int ReadOnlyValue
        {
            get { return myConst; }
        } 

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \property   public float WriteOnlyValue
        ///
        /// \brief  Sets the write only value. 
        ///
        /// \return The write only value. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public float WriteOnlyValue
        {
            set { speed = value; }
        } 

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \property   public byte[] Terminator
        ///
        /// \brief  Gets or sets the terminator. 
        ///
        /// \return The terminator. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public byte[] Terminator
        {
            get { return terminator;  }
            set { terminator = value; }
        } 

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public Velocity CalcAvgTruckVelocity()
        ///
        /// \brief  Calculates the average truck velocity. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \return The calculated average truck velocity. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public Velocity CalcAvgTruckVelocity()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void Add()
        ///
        /// \brief  Adds .
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void Add()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public bool Add(Item newItem)
        ///
        /// \brief  Adds newItem.
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  newItem The Item to add. 
        ///
        /// \return true if it succeeds, false if it fails. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public bool Add(Item newItem)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void AddToDictionary(Item newItem)
        ///
        /// \brief  Adds to the dictionary. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  newItem The new item. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void AddToDictionary(Item newItem)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void AddToList(Item newItem, List<Item> destList)
        ///
        /// \brief  Adds to the list. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  newItem     The new item. 
        /// \param  destList    List of destinations. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void AddToList(Item newItem, List<Item> destList)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public List<Velocity> calcShipVelocities(PairGeneric<int, string> shipData)
        ///
        /// \brief  Calculates the ship velocities. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  shipData    Information describing the ship. 
        ///
        /// \return The calculated ship velocities. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public List<Velocity> calcShipVelocities(PairGeneric<int, string> shipData)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \enum   TaskImportance
        ///
        /// \brief  Values that represent TaskImportance. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public enum TaskImportance
        {
            Low,
            Medium,
            High,
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \enum   ListOptions
        ///
        /// \brief  Bitfield of flags for specifying ListOptions. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        [Flags]
        public enum ListOptions
        {
            AllowNulls    = 1<<0,
            AllowDelete   = 1<<1,
            SortItems     = 1<<2,
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public __DECLSPEC bool VeryCommentedFunction( bool isUsed, int lastParam) const
        ///
        /// \brief  Very commented function. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  isUsed      true if is used. 
        /// \param  lastParam   The last parameter. 
        ///
        /// \return true if it succeeds, false if it fails. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public __DECLSPEC bool /**** void ****/
            VeryCommentedFunction(/* int removed / 56 *** */ bool  // End of line comment
                                    isUsed, int lastParam) const
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static MyObject[ , ][] *&ComplicatedPrototypeParsingTest(int *pThings,
        ///     int Stuff[] = (12 + 4) * (3+8), const float Number) const
        ///
        /// \brief  Tests complicated prototype parsing. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param [in,out] pThings If non-null, the things. 
        /// \param  Stuff           The stuff. 
        /// \param  Number          Number of. 
        ///
        /// \return null if it fails, else. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static MyObject[ , ][] *&ComplicatedPrototypeParsingTest(int *pThings,
                  int Stuff[] = (12 + 4) * (3+8),
                  const float Number) const
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public bool TestExceptionHandling(int myParam, int value)
        ///
        /// \brief  Tests exception handling. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \exception  FileNotFoundException       Thrown when the requested file is not present. 
        /// \exception  ArgumentException           Thrown when one or more arguments have unsupported or
        ///                                         illegal values. 
        /// \exception  InvalidOperationException   Thrown when the requested operation is invalid. 
        /// \exception  NotImplementedException     Thrown when the requested operation is unimplemented. 
        /// \exception  IndirectException           Thrown when indirect. 
        ///
        /// \param  myParam my parameter. 
        /// \param  value   The value. 
        ///
        /// \return true if the test passes, false if the test fails. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public bool TestExceptionHandling(int myParam, int value)
        {
            FileNotFoundException fileMissing;
            throw fileMissing;

            throw new ArgumentException("value");
            if (value > 5)
                throw(new InvalidOperationException());

            throw (new NotImplementedException("I forgot to do this"));

            try
            {
            }
            catch (IndirectException ex)
            {
                Debug.Trace("IndiretException was thrown");
                throw;        // Pass the exception on
            }
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn bool VariousExceptionThrowingTests()
        ///
        /// \brief  Various exception throwing tests. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \exception  RethrowException            Thrown when rethrow. 
        /// \exception  CatchThrownException        Thrown when catch thrown. 
        /// \exception  VariableThrownException     Thrown when variable thrown. 
        /// \exception  SimpleException             Thrown when simple. 
        /// \exception  BaseClassVariableException  Thrown when base class variable. 
        /// \exception  PathTooLongException        Thrown when the file/folder path is too long. 
        /// \exception  NeverCompiledException      Thrown when never compiled. 
        /// \exception  InBracketsException         Thrown when in brackets. 
        ///
        /// \return true if it succeeds, false if it fails. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool VariousExceptionThrowingTests()
        {
            // Test exceptions declared as variables and thrown later
            Exception baseEx = new BaseClassVariableException();
            VariableThrownException varEx = null;

            // Test cases that shouldn't confuse the parser
            FoundTheWrongException revarExcept = null;
            FoundTheWrongException revarEx = null;
            FoundTheWrongException varExcept = null;

            if (varEx == null)
                varEx = new VariableThrownException();

            try
            {
            }
            // Test a simple re-throw of a caught exception
            catch(RethrowException ex)
            {
                throw;
            }
            // Test a naughty re-throw of a caught exception via a variable name
            catch(CatchThrownException ex)
            {
                throw ex;
            }

            // Test throwing of an exception via a variable declared above
            if (true)
                throw varEx;

            // Test a simple exception throw
            throw new SimpleException();

            // Test throwing of an exception via a variable which is declared as a base class type,
            // but which is set to a more derived type.
            throw baseEx;

            // Another exception variable, this time looking a lot more like an exception classname
            Exception pathException = new PathTooLongException();
            throw pathException;

            // throw new SingleLineCommentException();

            /* Ignore commented-out code
             * throw new MultiLineCommentException();
             */

            // Atomineer currently processes exceptions inside #if blocks (as they are usually
            // used for code that is only temporarily disabled) 
#if false
            throw new NeverCompiledException();
#endif

            // And a different bracketing style
            throw(new InBracketsException("You can't do that!"));
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static T[] Partition<T,U>(this T[] source, int index, int count)
        ///
        /// \brief  Partition< t,u>. 
        ///
        /// \author Jason
        /// \date   21/01/2010
        ///
        /// \exception  ArgumentException   Thrown when one or more arguments have unsupported or illegal
        ///                                 values. 
        ///
        /// \typeparam  T   . 
        /// \typeparam  U   . 
        /// \param  source  Source for the. 
        /// \param  index   Zero-based index of the. 
        /// \param  count   Number of. 
        ///
        /// \return . 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static T[] Partition<T,U>(this T[] source, int index, int count) {
         if (index < 0 || count < 0 || source.Length – index < count)
            throw new ArgumentException();
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn bool PlainFunction()
        ///
        /// \brief  Plain function. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \return true if it succeeds, false if it fails. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool PlainFunction()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn bool IsDocked()
        ///
        /// \brief  Query if this object is docked. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \return true if docked, false if not. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool IsDocked()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn bool AreWindowsDockedOrFloating()
        ///
        /// \brief  Query if windows docked or floating. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \return true if windows docked or floating, false if not. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool AreWindowsDockedOrFloating()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn bool AreAnyWindowsOpen(List<Form> wndList)
        ///
        /// \brief  Query if any windows open in 'wndList'. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  wndList List of windows. 
        ///
        /// \return true if any windows open, false if not. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool AreAnyWindowsOpen(List<Form> wndList)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn bool IsAWindow(object typeToCheck)
        ///
        /// \brief  Query if 'typeToCheck' is a window. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  typeToCheck The type to check. 
        ///
        /// \return true if a window, false if not. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool IsAWindow(object typeToCheck)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn bool IsType(object typeToCheck)
        ///
        /// \brief  Query if 'typeToCheck' is type. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  typeToCheck The type to check. 
        ///
        /// \return true if type, false if not. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool IsType(object typeToCheck)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn bool AreReadyToTx()
        ///
        /// \brief  Query if ready to transmit. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \return true if ready to transmit, false if not. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool AreReadyToTx()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn bool ReadyToTx()
        ///
        /// \brief  Query if we are ready to transmit. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \return true if it succeeds, false if it fails. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool ReadyToTx()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn bool IsReadyToTransmit(CommsPort port)
        ///
        /// \brief  Query if 'port' is ready to transmit. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  port    The port. 
        ///
        /// \return true if ready to transmit, false if not. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool IsReadyToTransmit(CommsPort port)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn bool TestIfPrefsFileIsWritable(string pathname)
        ///
        /// \brief  Tests if preferences file is writable. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  pathname    Full pathname of the file. 
        ///
        /// \return true if the test passes, false if the test fails. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool TestIfPrefsFileIsWritable(string pathname)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public string FormatUIDesc(string format, params object[] formatValues)
        ///
        /// \brief  Format user interface description. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  format          Describes the format to use. 
        /// \param  formatValues    A variable-length parameters list containing format values. 
        ///
        /// \return The formatted user interface description. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public string FormatUIDesc(string format, params object[] formatValues)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public bool Equals(ItemDetails other)
        ///
        /// \brief  Tests if this ItemDetails is considered equal to another. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  other   The item details to compare to this object. 
        ///
        /// \return true if the objects are considered equal, false if they are not. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public bool Equals(ItemDetails other)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public bool Equals(ItemDetails a, ItemDetails b)
        ///
        /// \brief  Tests if two ItemDetails objects are considered equal. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  a   Item details to be compared. 
        /// \param  b   Item details to be compared. 
        ///
        /// \return true if the objects are considered equal, false if they are not. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public bool Equals(ItemDetails a, ItemDetails b)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public int CompareTo(EngineeringInfo a)
        ///
        /// \brief  Compares this EngineeringInfo object to another to determine their relative ordering.
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  a   Engineering information to compare to this. 
        ///
        /// \return Negative if this object is less than the other, 0 if they are equal, or positive if
        ///         this is greater. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int CompareTo(EngineeringInfo a){}

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static int Compare(EngineeringInfo infoA, EngineeringInfo infoB)
        ///
        /// \brief  Compares two EngineeringInfo objects to determine their relative ordering. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  infoA   Engineering information to be compared. 
        /// \param  infoB   Engineering information to be compared. 
        ///
        /// \return Negative if 'infoA' is less than 'infoB', 0 if they are equal, or positive if it is
        ///         greater. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static int Compare(EngineeringInfo infoA, EngineeringInfo infoB)    {}

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public int GetHashCode()
        ///
        /// \brief  Calculates the hash code for this object. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \return The hash code for this object. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int GetHashCode() {}

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public string ToString()
        ///
        /// \brief  Convert this object into a string representation. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \return A string representation of this object. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public string ToString()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public string ToString(string format)
        ///
        /// \brief  Convert this object into a string representation. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  format  Describes the format to use. 
        ///
        /// \return A string representation of this object. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public string ToString(string format)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public DataBlock ToInternalFormat()
        ///
        /// \brief  Converts this object to an internal format. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \return This object as a DataBlock. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public DataBlock ToInternalFormat()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public DataBlock ToInternalFormat(int value)
        ///
        /// \brief  Converts a value to an internal format. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  value   The value. 
        ///
        /// \return This object as a DataBlock. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public DataBlock ToInternalFormat(int value)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static Counter operator+(Counter ctr1, Counter ctr2)
        ///
        /// \brief  Addition operator. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  ctr1    The first counter. 
        /// \param  ctr2    The second counter. 
        ///
        /// \return The result of the operation. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Counter operator +(Counter ctr1, Counter ctr2)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static Counter operator++(int increment)
        ///
        /// \brief  Postfix increment operator. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  increment   Amount to increment by. 
        ///
        /// \return The result of the operation. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static Counter operator ++(int increment)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void SetCamPos(float x1, float y)
        ///
        /// \brief  Sets a camera position. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  x   The x coordinate. 
        /// \param  y   The y coordinate. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void SetCamPos(float x, float y)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public void SetDisplayRect(float x1, float y1, float x2, float y2)
        ///
        /// \brief  Sets a display rectangle. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  x1  The first x value. 
        /// \param  y1  The first y value. 
        /// \param  x2  The second x value. 
        /// \param  y2  The second y value. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void SetDisplayRect(float x1, float y1, float x2, float y2)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static bool operator>(Score score1, Score score2)
        ///
        /// \brief  Greater-than comparison operator. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  score1  The first score. 
        /// \param  score2  The second score. 
        ///
        /// \return true if the first parameter is greater than to the second. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator >(Score score1, Score score2)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static implicit operator Description(string val)
        ///
        /// \brief  Description casting operator. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  val The value. 
        ///
        /// \return The result of the operation. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static implicit operator Description(string val)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static explicit operatorbool(DataItem value)
        ///
        /// \brief   casting operator. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  value   The value. 
        ///
        /// \return The result of the operation. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static explicit operator bool(DataItem value) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static explicit operatorDataBlock(DataItem x)
        ///
        /// \brief  Data block casting operator. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  x   The x coordinate. 
        ///
        /// \return The result of the operation. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static explicit operator DataBlock(DataItem x) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static DataItem operator==(DataItem x, DataItem y)
        ///
        /// \brief  Equality operator. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  x   The x coordinate. 
        /// \param  y   The y coordinate. 
        ///
        /// \return true if the parameters are considered equivalent. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static DataItem operator ==(DataItem x, DataItem y) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static DataItem operator!=(DataItem x, DataItem y)
        ///
        /// \brief  Inequality operator. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  x   The x coordinate. 
        /// \param  y   The y coordinate. 
        ///
        /// \return true if the parameters are not considered equivalent. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static DataItem operator !=(DataItem x, DataItem y) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static DataItem operator!(DataItem x)
        ///
        /// \brief  Logical negation operator. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  x   The x coordinate. 
        ///
        /// \return The logical inverse of this value. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static DataItem operator !(DataItem x) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static DataItem operator&(DataItem x, DataItem y)
        ///
        /// \brief  Bitwise 'and' operator. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  x   The x coordinate. 
        /// \param  y   The y coordinate. 
        ///
        /// \return The result of the operation. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static DataItem operator&(DataItem x, DataItem y) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static DataItem operator|(DataItem x, DataItem y)
        ///
        /// \brief  Bitwise 'or' operator. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  x   The x coordinate. 
        /// \param  y   The y coordinate. 
        ///
        /// \return The result of the operation. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static DataItem operator |(DataItem x, DataItem y) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public static bool operatortrue(DataItem x)
        ///
        /// \brief  Boolean 'true' operator. 
        ///
        /// \author Jason Williams
        /// \date   21/01/2010
        ///
        /// \param  x   The x coordinate. 
        ///
        /// \return true if this object is in a 'true' state, else false. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator true(DataItem x) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \fn public string this[int pos]
        ///
        /// \brief  Indexer to get or set items within this collection using array index syntax. 
        ///
        /// \return The indexed item. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public string this[int pos]
        {
            get {}
            set {}
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \property   public int NumPassengers
        ///
        /// \brief  Gets the number of passengers. 
        ///
        /// \return The total number of passengers. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int NumPassengers
        {
            get { return(5);    }
//          set {}
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \property   public int MaxSpeed
        ///
        /// \brief  Sets the maximum speed. 
        ///
        /// \return The maximum speed. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int MaxSpeed
        {
         /* get { return(5);    } */
            set {}
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \property   public bool IsActive
        ///
        /// \brief  Gets a value indicating whether this object is active. 
        ///
        /// \return true if this object is active, false if not. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public bool IsActive
        {
            get { return(true);    }
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \property   public bool ShouldDelFileOnExit
        ///
        /// \brief  Gets a value indicating whether we should delete file on exit. 
        ///
        /// \return true if we should delete file on exit, false if not. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public bool ShouldDelFileOnExit
        {
            get { }
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \property   public int Average
        ///
        /// \brief  Gets the average. 
        ///
        /// \return The average. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int Average { get {} }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \property   public int NumEngines
        ///
        /// \brief  Gets or sets the number of engines. 
        ///
        /// \return The total number of engines. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int NumEngines { get {}; set {} }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// \property   public Color FgColour
        ///
        /// \brief  Gets or sets the colour of the foreground. 
        ///
        /// \return The colour of the foreground. 
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public Color FgColour { get {}; set {} }


        //! Number of passengers
        private int numPassengers;

        //! List of passengers
        private List<int> passengerList;

        //! The name value pair
        private Pair<int, string> nameValuePair;
    }
}


//---------------------------------------------------------------------------------------------------
// C++ specific examples
//---------------------------------------------------------------------------------------------------

////////////////////////////////////////////////////////////////////////////////////////////////////
/// \fn CppTestClass::CppTestClass(void)
///
/// \brief  Default constructor. 
///
/// \author Jason Williams
/// \date   21/01/2010
////////////////////////////////////////////////////////////////////////////////////////////////////

CppTestClass::CppTestClass(void)
{
}

////////////////////////////////////////////////////////////////////////////////////////////////////
/// \fn CppTestClass::CppTestClass(int value)
///
/// \brief  Constructor. 
///
/// \author Jason Williams
/// \date   21/01/2010
///
/// \param  value   The value. 
////////////////////////////////////////////////////////////////////////////////////////////////////

CppTestClass::CppTestClass(int value)
{
}

////////////////////////////////////////////////////////////////////////////////////////////////////
/// \fn CppTestClass::~CppTestClass()
///
/// \brief  Destructor. 
///
/// \author Jason Williams
/// \date   21/01/2010
////////////////////////////////////////////////////////////////////////////////////////////////////

CppTestClass::~CppTestClass()
{
}

////////////////////////////////////////////////////////////////////////////////////////////////////
/// \fn int CppTestClass::GetValue()
///
/// \brief  Gets the value. 
///
/// \author Jason Williams
/// \date   21/01/2010
///
/// \return The value. 
////////////////////////////////////////////////////////////////////////////////////////////////////

int CppTestClass::GetValue()
{
    return(value);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
/// \fn BOOL ViewLevel::PreCreateWindow(CREATESTRUCT& cs)
///
/// \brief  Pre create window. 
///
/// \author Jason Williams
/// \date   21/01/2010
///
/// \param [in,out] cs  The create struct. 
///
/// \return true if it succeeds, false if it fails. 
////////////////////////////////////////////////////////////////////////////////////////////////////

BOOL ViewLevel::PreCreateWindow(CREATESTRUCT& cs)
{
    return CView::PreCreateWindow(cs);
}

////////////////////////////////////////////////////////////////////////////////////////////////////
/// \fn void ViewLevel::OnResizeWindow(void)
///
/// \brief  Executes the resize window action. 
///
/// \author Jason Williams
/// \date   21/01/2010
////////////////////////////////////////////////////////////////////////////////////////////////////

void ViewLevel::OnResizeWindow(void)
{
}

////////////////////////////////////////////////////////////////////////////////////////////////////
/// \fn void ViewLevel::OnDraw(CDC* pDC)
///
/// \brief  Executes the draw action. 
///
/// \author Jason Williams
/// \date   21/01/2010
///
/// \param [in,out] pDC If non-null, the device-context. 
////////////////////////////////////////////////////////////////////////////////////////////////////

void ViewLevel::OnDraw(CDC* pDC)
{
}

//---------------------------------------------------------------------------------------------------
// "Implement Function" example
//---------------------------------------------------------------------------------------------------

// Get the first thing that matches value.
Thing* GetThing(int value, bool *pResult=NULL, int *pNumber = NULL);

////////////////////////////////////////////////////////////////////////////////////////////////////
/// \fn Thing* AtomineerExamples::GetThing(int value, bool *pResult, int *pNumber)
///
/// \brief  Get the first thing that matches value.
///
/// \author Jason Williams
/// \date   21/01/2010
///
/// \param  value           The value. 
/// \param [out]    pResult if non-null, the result. 
/// \param [in,out] pNumber If non-null, number of. 
///
/// \return null if it fails, else the thing. 
////////////////////////////////////////////////////////////////////////////////////////////////////

Thing* AtomineerExamples::GetThing(int value, bool *pResult, int *pNumber)
{
    
    return(NULL);
}


//---------------------------------------------------------------------------------------------------
// "Implement Function" example
//---------------------------------------------------------------------------------------------------

// Get the first thing that matches value
// and return a boolean indicating if there
// are more things with that value in the list.
Thing& GetThing(int value, bool *pResult= NULL);

////////////////////////////////////////////////////////////////////////////////////////////////////
/// \fn Thing& AtomineerExamples::GetThing(int value, bool *pResult)
///
/// \brief  Get the first thing that matches value and return a boolean indicating if there are
///         more things with that value in the list. 
///
/// \author Jason Williams
/// \date   21/01/2010
///
/// \param  value         The value. 
/// \param [out]  pResult If non-null, the result. 
///
/// \return The thing. 
////////////////////////////////////////////////////////////////////////////////////////////////////

Thing& AtomineerExamples::GetThing(int value, bool *pResult)
{
    
}


//---------------------------------------------------------------------------------------------------
// "Implement Function" example
//---------------------------------------------------------------------------------------------------

//Test a bool value
bool BoolValue(void);

////////////////////////////////////////////////////////////////////////////////////////////////////
/// \fn bool AtomineerExamples::BoolValue(void)
///
/// \brief  Test a bool value. 
///
/// \author Jason Williams
/// \date   21/01/2010
///
/// \return true if it succeeds, false if it fails. 
////////////////////////////////////////////////////////////////////////////////////////////////////

bool AtomineerExamples::BoolValue(void)
{
    
    return(false);
}

 
Copyright © 1996-2014 Atomineer. All Rights Reserved. Any trademarks reproduced in this text are the property of their respective owners. Contact us