at*mineer
Follow us on Twitter

XML Documentation Comment Examples

Below are a number of examples of the automatic documentation generated by Atomineer in its default configuration.
These are exactly as generated by Atomineer, without any human intervention.

////////////////////////////////////////////////////////////////////////////////////////////////////
// file:    Examples\AtomineerExamplesDocXml.cs
//
// summary: Implements the atomineer utils examples document xml class
////////////////////////////////////////////////////////////////////////////////////////////////////

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

namespace Test
{
    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Interface for objects that provide custom disposal implementations. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    [SomethingAttribute]
    public interface IDisposable
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Additional information for communications error events. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    [AnotherAttribute]
    internal class CommsErrorEventArgs : EventArgs
    {
    } 

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Attribute for custom information. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    protected class CustomInfoAttr
    {
    }

      ////////////////////////////////////////////////////////////////////////////////////////////////////
      /// <summary> Attribute for object editor. </summary>
      ///
      /// <remarks> Jason Williams, 20/01/2010. </remarks>
      ////////////////////////////////////////////////////////////////////////////////////////////////////

      public class ObjEditorAttribute
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Form for viewing the data table. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class DataTblForm : Form
    {        
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Dialog for setting the preferences. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class PrefsDlg : Form
    {        
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Dialog for reporting errors to the user. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class ErrorDialog : Form
    {        
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Wizard for creating new items. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class CreateNewItemWizard : Form
    {        
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Exception for signalling pants on fire errors. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class PantsOnFireException : ArgumentNullException
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Additional information for big explosion events. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    internal class BigExplosionEventArgs
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Collection of playing cards. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public abstract class PlayingCardCollection
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Collection of window handles. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public abstract class WndHandleColl
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   List of window pointers. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    internal class WndPtrList
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Buffer for serial communications. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class SerialCommsBuffer
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Information about the user. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class UserInfo
    {
    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////
    /// <summary>   Test class. </summary>
    ///
    /// <remarks>   Jason Williams, 20/01/2010. </remarks>
    ////////////////////////////////////////////////////////////////////////////////////////////////////

    public class TestClass
    {
        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Constructor. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="manufacturerNames">    List of names of the manufacturers. </param>
        /// <param name="modelName">            Name of the model. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Tests automatic parameter generation. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="numItems">         Number of items. </param>
        /// <param name="numberOfBlocks">   Number of blocks. </param>
        /// <param name="configFilename">   Filename of the configuration file. </param>
        /// <param name="jobType">          Type of the job. </param>
        /// <param name="parseOptions">     Options for controlling the parse. </param>
        /// <param name="UserIdList">       List of user identifiers. </param>
        /// <param name="fgColour">         The foreground colour. </param>
        /// <param name="widthOfWingsInCm"> Width of the wings in centimetres. </param>
        /// <param name="listSize">         Size of the list. </param>
        /// <param name="listItemCount">    Number of list items. </param>
        /// <param name="listLength">       Length of the list. </param>
        /// <param name="rectWidth">        Width of the rectangle. </param>
        /// <param name="circleHeight">     Height of the circle. </param>
        /// <param name="serialIOBuff">     [in,out] If non-null, buffer for serial i/o data. </param>
        /// <param name="fileDataMgr">      [in,out] Manager for file data. </param>
        /// <param name="parseCtx">         Context for the parse. </param>
        /// <param name="userInfo">         [in,out] Information describing the user. </param>
        /// <param name="RAIDArrayID">      [out] Identifier for the raid array. </param>
        /// <param name="programIds">       List of identifiers for the programs. </param>
        ///
        /// <returns>   true if the test passes, false if the test fails. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        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)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Tests parameter alignment. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="a">                a. </param>
        /// <param name="ab">               The ab. </param>
        /// <param name="abc">              The abc. </param>
        /// <param name="abcd">             The abcd. </param>
        /// <param name="abcde">            The abcde. </param>
        /// <param name="abcdef">           The abcdef. </param>
        /// <param name="abcdefg">          The abcdefg. </param>
        /// <param name="abcdefgh">         The abcdefgh. </param>
        /// <param name="abcdefghi">        The abcdefghi. </param>
        /// <param name="abcdefghij">       The abcdefghij. </param>
        /// <param name="abcdefghijk">      The abcdefghijk. </param>
        /// <param name="abcdefghijkl">     The abcdefghijkl. </param>
        /// <param name="abcdefghijklm">    The abcdefghijklm. </param>
        /// <param name="abcdefghijklmn">   The abcdefghijklmn. </param>
        /// <param name="abcdefghijklmno">  The abcdefghijklmno. </param>
        /// <param name="abcdefghijklmnop"> The abcdefghijklmnop. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        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)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Initialises this object. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void Initialise()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Initializes the graduated fill. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void InitializeGradFill()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Initialises the file buffers. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void InitFileBuffers()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Sets up the uninstaller. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="settingsElem"> Element describing the settings. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void SetUpUninstaller(XmlElement settingsElem)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Execute all child install commands of the given command root element. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="cmdRootElem">  Element describing the command root. </param>
        ///
        /// <returns>   true if it succeeds, false if it fails. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        static bool ExecuteAllChildInstallCommandsOf(XmlElement cmdRootElem)
        {
        }         

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Connects to backup data server. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void ConnectToBackupDataSvr()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Transmit data to backup server. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void TxDataToBackupSvr()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Dumps a flight information. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="passengerManifest">    [out] A list of passengers. </param>
        /// <param name="manifestSize">         [in,out] Size of the manifest. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Reports the errors. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void ReportErrors()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Reports an error. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="format">   Describes the format to use. </param>
        /// <param name="args">     A variable-length parameters list containing arguments. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Writes the warnings. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void WriteWarnings()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Writes a warning. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="format">   Describes the format to use. </param>
        /// <param name="args">     A variable-length parameters list containing arguments. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Writes a warning. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="report">   The report. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void WriteWarning(string report)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Writes the warning. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        private static void WriteWarning()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Adds text.</summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="text"> The string to add. </param>
        ///
        /// <returns>   true if it succeeds, false if it fails. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public bool Add(string text)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Adds a new item to 'itemList'. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="item">     The item. </param>
        /// <param name="itemList"> List of items. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Adds a new item. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="item"> The item. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void AddNewItem(string item)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Appends an entry. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="entry">    The entry. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void AppendEntry(int entry)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Appends an entry. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="entry">    The string to append. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void Append(string entry)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Appends a new entry. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="entry">    The entry. </param>
        ///
        /// <returns>   . </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public Block AppendNewEntry(int entry)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Appends an entry. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="userData"> Information describing the user. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void AppendEntry(Block userData)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Appends an entry. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="userData">     Information describing the user. </param>
        /// <param name="entryList">    List of entries. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Writes an entry. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="machineInfo">  Information describing the machine. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void WriteEntry(string machineInfo)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Writes an entry. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="machineInfo">  Information describing the machine. </param>
        /// <param name="outputStream"> The output stream. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Writes. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="machineInfo">  The string to write. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void Write(string machineInfo)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Delegate for handling NewGovernment events. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="sender">   Source of the event. </param>
        /// <param name="e">        New government event information. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        /// <summary> The military coup event </summary>
        public NewGovernmentEventHandler MilitaryCoupEvent;

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Raises the military coup event. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="e">    Event information to send to registered event handlers. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        protected virtual void OnMilitaryCoup(EventArgs e) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Raises the military coup event. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="e">    Event information to send to registered event handlers. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        protected virtual void RaiseMilitaryCoup(EventArgs e) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Event handler. Called by NewsListener for military coup events. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="sender">   Source of the event. </param>
        /// <param name="e">        Coup event information. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        void NewsListener_MilitaryCoupEvent(object sender, CoupEventArgs e)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Gets the read only value. </summary>
        ///
        /// <value> The read only value. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int ReadOnlyValue
        {
            get { return myConst; }
        } 

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Sets the write only value. </summary>
        ///
        /// <value> The write only value. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Gets or sets the terminator. </summary>
        ///
        /// <value> The terminator. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Calculates the average truck velocity. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <returns>   The calculated average truck velocity. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public Velocity CalcAvgTruckVelocity()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Adds .</summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void Add()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Adds newItem.</summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="newItem">  The Item to add. </param>
        ///
        /// <returns>   true if it succeeds, false if it fails. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public bool Add(Item newItem)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Adds to the dictionary. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="newItem">  The new item. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public void AddToDictionary(Item newItem)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Adds to the list. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="newItem">  The new item. </param>
        /// <param name="destList"> List of destinations. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Calculates the ship velocities. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="shipData"> Information describing the ship. </param>
        ///
        /// <returns>   The calculated ship velocities. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Values that represent TaskImportance. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public enum TaskImportance
        {
            Low,
            Medium,
            High,
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Bitfield of flags for specifying ListOptions. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Very commented function. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="isUsed">       true if is used. </param>
        /// <param name="lastParam">    The last parameter. </param>
        ///
        /// <returns>   true if it succeeds, false if it fails. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Tests complicated prototype parsing. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="pThings">  [in,out] If non-null, the things. </param>
        /// <param name="Stuff">    The stuff. </param>
        /// <param name="Number">   Number of. </param>
        ///
        /// <returns>   null if it fails, else. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Tests exception handling. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <exception cref="FileNotFoundException">        Thrown when the requested file is not
        ///                                                 present. </exception>
        /// <exception cref="ArgumentException">            Thrown when one or more arguments have
        ///                                                 unsupported or illegal values. </exception>
        /// <exception cref="InvalidOperationException">    Thrown when the requested operation is
        ///                                                 invalid. </exception>
        /// <exception cref="NotImplementedException">      Thrown when the requested operation is
        ///                                                 unimplemented. </exception>
        /// <exception cref="IndirectException">            Thrown when indirect. </exception>
        ///
        /// <param name="myParam">  my parameter. </param>
        /// <param name="value">    The value. </param>
        ///
        /// <returns>   true if the test passes, false if the test fails. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        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
            }
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Various exception throwing tests. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <exception cref="RethrowException">             Thrown when rethrow. </exception>
        /// <exception cref="CatchThrownException">         Thrown when catch thrown. </exception>
        /// <exception cref="VariableThrownException">      Thrown when variable thrown. </exception>
        /// <exception cref="SimpleException">              Thrown when simple. </exception>
        /// <exception cref="BaseClassVariableException">   Thrown when base class variable. </exception>
        /// <exception cref="PathTooLongException">         Thrown when the file/folder path is too long. </exception>
        /// <exception cref="NeverCompiledException">       Thrown when never compiled. </exception>
        /// <exception cref="InBracketsException">          Thrown when in brackets. </exception>
        ///
        /// <returns>   true if it succeeds, false if it fails. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        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!"));
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Partition< t,u>. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <exception cref="ArgumentException">    Thrown when one or more arguments have unsupported or
        ///                                         illegal values. </exception>
        ///
        /// <typeparam name="T">    . </typeparam>
        /// <typeparam name="U">    . </typeparam>
        /// <param name="source">   Source for the. </param>
        /// <param name="index">    Zero-based index of the. </param>
        /// <param name="count">    Number of. </param>
        ///
        /// <returns>   . </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        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();
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Plain function. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <returns>   true if it succeeds, false if it fails. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool PlainFunction()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Query if this object is docked. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <returns>   true if docked, false if not. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool IsDocked()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Query if windows docked or floating. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <returns>   true if windows docked or floating, false if not. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool AreWindowsDockedOrFloating()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Query if any windows open in 'wndList'. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="wndList">  List of windows. </param>
        ///
        /// <returns>   true if any windows open, false if not. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool AreAnyWindowsOpen(List<Form> wndList)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Query if 'typeToCheck' is a window. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="typeToCheck">  The type to check. </param>
        ///
        /// <returns>   true if a window, false if not. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool IsAWindow(object typeToCheck)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Query if 'typeToCheck' is type. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="typeToCheck">  The type to check. </param>
        ///
        /// <returns>   true if type, false if not. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool IsType(object typeToCheck)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Query if ready to transmit. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <returns>   true if ready to transmit, false if not. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool AreReadyToTx()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Query if we are ready to transmit. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <returns>   true if it succeeds, false if it fails. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool ReadyToTx()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Query if 'port' is ready to transmit. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="port"> The port. </param>
        ///
        /// <returns>   true if ready to transmit, false if not. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool IsReadyToTransmit(CommsPort port)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Tests if preferences file is writable. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="pathname"> Full pathname of the file. </param>
        ///
        /// <returns>   true if the test passes, false if the test fails. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        bool TestIfPrefsFileIsWritable(string pathname)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Format user interface description. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="format">       Describes the format to use. </param>
        /// <param name="formatValues"> A variable-length parameters list containing format values. </param>
        ///
        /// <returns>   The formatted user interface description. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Tests if this ItemDetails is considered equal to another. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="other">    The item details to compare to this object. </param>
        ///
        /// <returns>   true if the objects are considered equal, false if they are not. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public bool Equals(ItemDetails other)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Tests if two ItemDetails objects are considered equal. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="a">    Item details to be compared. </param>
        /// <param name="b">    Item details to be compared. </param>
        ///
        /// <returns>   true if the objects are considered equal, false if they are not. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   
        /// Compares this EngineeringInfo object to another to determine their relative ordering. 
        /// </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="a">    Engineering information to compare to this. </param>
        ///
        /// <returns>   
        /// Negative if this object is less than the other, 0 if they are equal, or positive if this is
        /// greater. 
        /// </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int CompareTo(EngineeringInfo a){}

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Compares two EngineeringInfo objects to determine their relative ordering. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="infoA">    Engineering information to be compared. </param>
        /// <param name="infoB">    Engineering information to be compared. </param>
        ///
        /// <returns>   
        /// Negative if 'infoA' is less than 'infoB', 0 if they are equal, or positive if it is greater. 
        /// </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Calculates the hash code for this object. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <returns>   The hash code for this object. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int GetHashCode() {}

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Convert this object into a string representation. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <returns>   A string representation of this object. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public string ToString()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Convert this object into a string representation. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="format">   Describes the format to use. </param>
        ///
        /// <returns>   A string representation of this object. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public string ToString(string format)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Converts this object to an internal format. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <returns>   This object as a DataBlock. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public DataBlock ToInternalFormat()
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Converts a value to an internal format. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="value">    The value. </param>
        ///
        /// <returns>   This object as a DataBlock. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public DataBlock ToInternalFormat(int value)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Addition operator. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="ctr1"> The first counter. </param>
        /// <param name="ctr2"> The second counter. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Postfix increment operator. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="increment">    Amount to increment by. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Sets a camera position. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="x">    The x coordinate. </param>
        /// <param name="y">    The y coordinate. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Sets a display rectangle. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="x1">   The first x value. </param>
        /// <param name="y1">   The first y value. </param>
        /// <param name="x2">   The second x value. </param>
        /// <param name="y2">   The second y value. </param>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Greater-than comparison operator. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="score1">   The first score. </param>
        /// <param name="score2">   The second score. </param>
        ///
        /// <returns>   true if the first parameter is greater than to the second. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Description casting operator. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="val">  The value. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static implicit operator Description(string val)
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   bool casting operator. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="value">    The value. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static explicit operator bool(DataItem value) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Data block casting operator. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="x">    The x coordinate. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static explicit operator DataBlock(DataItem x) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Equality operator. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="x">    The x coordinate. </param>
        /// <param name="y">    The y coordinate. </param>
        ///
        /// <returns>   true if the parameters are considered equivalent. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Inequality operator. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="x">    The x coordinate. </param>
        /// <param name="y">    The y coordinate. </param>
        ///
        /// <returns>   true if the parameters are not considered equivalent. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Logical negation operator. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="x">    The x coordinate. </param>
        ///
        /// <returns>   The logical inverse of this value. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static DataItem operator !(DataItem x) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Bitwise 'and' operator. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="x">    The x coordinate. </param>
        /// <param name="y">    The y coordinate. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Bitwise 'or' operator. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="x">    The x coordinate. </param>
        /// <param name="y">    The y coordinate. </param>
        ///
        /// <returns>   The result of the operation. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Boolean 'true' operator. </summary>
        ///
        /// <remarks>   Jason Williams, 20/01/2010. </remarks>
        ///
        /// <param name="x">    The x coordinate. </param>
        ///
        /// <returns>   true if this object is in a 'true' state, else false. </returns>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public static bool operator true(DataItem x) 
        {
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Indexer to get or set items within this collection using array index syntax. </summary>
        ///
        /// <value> The indexed item. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Gets the number of passengers. </summary>
        ///
        /// <value> The total number of passengers. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Sets the maximum speed. </summary>
        ///
        /// <value> The maximum speed. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Gets a value indicating whether this object is active. </summary>
        ///
        /// <value> true if this object is active, false if not. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Gets a value indicating whether we should delete file on exit. </summary>
        ///
        /// <value> true if we should delete file on exit, false if not. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public bool ShouldDelFileOnExit
        {
            get { }
        }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Gets the average. </summary>
        ///
        /// <value> The average. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

        public int Average { get {} }

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Gets or sets the number of engines. </summary>
        ///
        /// <value> The total number of engines. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

        ////////////////////////////////////////////////////////////////////////////////////////////////////
        /// <summary>   Gets or sets the colour of the foreground. </summary>
        ///
        /// <value> The colour of the foreground. </value>
        ////////////////////////////////////////////////////////////////////////////////////////////////////

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

         
        /// <summary> Number of passengers </summary>
        private int numPassengers;

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

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


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


////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>   Default constructor. </summary>
///
/// <remarks>   Jason Williams, 20/01/2010. </remarks>
////////////////////////////////////////////////////////////////////////////////////////////////////

CppTestClass::CppTestClass(void)
{
}

////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>   Constructor. </summary>
///
/// <remarks>   Jason Williams, 20/01/2010. </remarks>
///
/// <param name="value">    The value. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////

CppTestClass::CppTestClass(int value)
{
}

////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>   Destructor. </summary>
///
/// <remarks>   Jason Williams, 20/01/2010. </remarks>
////////////////////////////////////////////////////////////////////////////////////////////////////

CppTestClass::~CppTestClass()
{
}

////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>   Gets the value. </summary>
///
/// <remarks>   Jason Williams, 20/01/2010. </remarks>
///
/// <returns>   The value. </returns>
////////////////////////////////////////////////////////////////////////////////////////////////////

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

////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>   Pre create window. </summary>
///
/// <remarks>   Jason Williams, 20/01/2010. </remarks>
///
/// <param name="cs">   [in,out] The create struct. </param>
///
/// <returns>   true if it succeeds, false if it fails. </returns>
////////////////////////////////////////////////////////////////////////////////////////////////////

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

////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>   Executes the resize window action. </summary>
///
/// <remarks>   Jason Williams, 20/01/2010. </remarks>
////////////////////////////////////////////////////////////////////////////////////////////////////

void ViewLevel::OnResizeWindow(void)
{
}

////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>   Executes the draw action. </summary>
///
/// <remarks>   Jason Williams, 20/01/2010. </remarks>
///
/// <param name="pDC">  [in,out] If non-null, the device-context. </param>
////////////////////////////////////////////////////////////////////////////////////////////////////

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);

////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>   Get the first thing that matches value. </summary>
///
/// <remarks>   Jason Williams, 20/01/2010. </remarks>
///
/// <param name="value">    The value. </param>
/// <param name="pResult">  [out] if non-null, the result. </param>
/// <param name="pNumber">  [in,out] If non-null, number of. </param>
///
/// <returns>   null if it fails, else the thing. </returns>
////////////////////////////////////////////////////////////////////////////////////////////////////

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);

////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>   
/// Get the first thing that matches value and return a boolean indicating if there are more
/// things with that value in the list. 
/// </summary>
///
/// <remarks>   Jason Williams, 20/01/2010. </remarks>
///
/// <param name="value">    The value. </param>
/// <param name="pResult">  [out] if non-null, the result. </param>
///
/// <returns>   The thing. </returns>
////////////////////////////////////////////////////////////////////////////////////////////////////

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


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

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

////////////////////////////////////////////////////////////////////////////////////////////////////
/// <summary>   Test a bool value. </summary>
///
/// <remarks>   Jason Williams, 20/01/2010. </remarks>
///
/// <returns>   true if it succeeds, false if it fails. </returns>
////////////////////////////////////////////////////////////////////////////////////////////////////

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