DotNetFrameworkDev/GenericTeProgramLibrary
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial check-in

Browse Source
This commit is contained in:
Duc
2025-01-03 09:50:39 -07:00
parent 45596e360d
commit 1d8f6e4c96
143 changed files with 9835 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
Source/Program/Common/Misc/EventGroup.cs Normal file
View File

@@ -0,0 +1,154 @@
/*-------------------------------------------------------------------------
// UNCLASSIFIED
/*-------------------------------------------------------------------------
RAYTHEON PROPRIETARY: THIS DOCUMENT CONTAINS DATA OR INFORMATION
PROPRIETARY TO RAYTHEON COMPANY AND IS RESTRICTED TO USE ONLY BY PERSONS
AUTHORIZED BY RAYTHEON COMPANY IN WRITING TO USE IT. DISCLOSURE TO
UNAUTHORIZED PERSONS WOULD LIKELY CAUSE SUBSTANTIAL COMPETITIVE HARM TO
RAYTHEON COMPANY'S BUSINESS POSITION. NEITHER SAID DOCUMENT NOR ITS
CONTENTS SHALL BE FURNISHED OR DISCLOSED TO OR COPIED OR USED BY PERSONS
OUTSIDE RAYTHEON COMPANY WITHOUT THE EXPRESS WRITTEN APPROVAL OF RAYTHEON
COMPANY.
THIS PROPRIETARY NOTICE IS NOT APPLICABLE IF DELIVERED TO THE U.S.
GOVERNMENT.
UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
-------------------------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace ProgramLib
{
/// <summary>
/// Class that maps event array index to any event enumeration and wraps the WaitHandle.WaitAny() function
/// Use case:
/// When calling WaitHandle.WaitAny(EventArray), it only returns the index of the event in the array that is being signalled.
/// Refering to an index of the array to know which event it is is not ideal. We want to be able to refer to an enumeration instead
/// Usage:
/// In class that uses this class, must define a enumeration
/// public enum Events
/// {
/// EVENT1,
/// EVENT2,
/// EVENT3,
/// EVENTN
///
/// // DO NOT change the name
/// // This must be the last member in the enum
/// EVENT_TIMED_OUT
/// }
/// Dictionary<Events, EventWaitHandle> dict = new Dictionary<Events, EventWaitHandle>();
/// dict[Events.EVENT1] = new ManualResetEvent(false);
/// dict[Events.EVENT2] = new AutoResetEvent(false);
/// dict[Events.EVENT3] = new ManualResetEvent(false);
/// dict[Events.EVENTN] = new AutoResetEvent(false);
/// dict[Events.EVENT_TIMED_OUT] = null;
///
/// EventGroup<Events, EventWaitHandle> eventGroup = new EventGroup<Events, EventWaitHandle>(dict);
///
/// Events id = eventGroup.WaitAny([Optional_timeout]);
///
/// if (id == Events.EVENT_TIMED_OUT){} // only if timeout was specified
/// if (id == Events.EVENT1){}
///
/// </summary>
internal class EventGroup<T1,T2>
{
Dictionary<T1, T2> _eventDict = null;
T2[] _eventArray = null;
/// <summary>
/// Constructor
/// </summary>
private EventGroup()
{
}
/// <summary>
/// Constructor
/// The event enum passed in must be defined in the following format:
/// public enum Events
/// {
/// EVENT1,
/// EVENT2,
/// EVENT3,
/// EVENTN
///
/// // DO NOT change the name
/// // This must be the last member in the enum
/// EVENT_TIMED_OUT
/// }
/// </summary>
/// <param name="eventDict">A dictionary that contains event enum that is associated to an event object</param>
public EventGroup(Dictionary<T1, T2> eventDict)
{
if (eventDict == null)
throw new Exception($"{nameof(eventDict)} cannot be null");
if (!eventDict.First().Key.GetType().IsEnum)
{
throw new Exception($"{nameof(eventDict)}'s key must be an enumerated type");
}
// get the last element in the dictionary
var element = eventDict.ElementAt(eventDict.Count - 1);
// check if the name of the last enum member is what we expect
string actualNameOfLastEnumMember = ((Enum)Convert.ChangeType(element.Key, typeof(Enum))).ToString();
string expectedNameOfLastEnumMember = "EVENT_TIMED_OUT";
if (actualNameOfLastEnumMember != expectedNameOfLastEnumMember)
{
throw new Exception($"Enum {element.Key.GetType().Name} must have {expectedNameOfLastEnumMember} as its last member. {nameof(eventDict)} must have {expectedNameOfLastEnumMember} as the last key in the dictionary");
}
if (eventDict.First().Value.GetType().BaseType != typeof(EventWaitHandle))
{
throw new Exception($"{nameof(eventDict)}'s value must be ManualResetEvent or AutoResetEvent type");
}
_eventDict = eventDict;
_eventArray = new T2[_eventDict.Count - 1];
int index = 0;
foreach (KeyValuePair<T1, T2> entry in _eventDict)
{
if (index < _eventDict.Count - 1)
_eventArray[index++] = entry.Value;
}
}
/// <summary>
/// Return the enumerated event based on the index of the event in the event array that is being signalled
/// </summary>
/// <param name="timeoutMilliseconds">time out in milliseconds</param>
public T1 WaitAny(int? timeoutMilliseconds = null)
{
int index = 0;
T1 eventId = default;
if (timeoutMilliseconds == null)
index = WaitHandle.WaitAny((EventWaitHandle[])Convert.ChangeType(_eventArray, typeof(EventWaitHandle[])));
else
index = WaitHandle.WaitAny((EventWaitHandle[])Convert.ChangeType(_eventArray, typeof(EventWaitHandle[])), (int)timeoutMilliseconds);
if (index == WaitHandle.WaitTimeout)
{
var element = _eventDict.ElementAt(_eventDict.Count - 1);
eventId = element.Key;
}
else
{
var element = _eventDict.ElementAt(index);
eventId = element.Key;
}
return eventId;
}
}
}

39
Source/Program/Common/Misc/EventManager.Datatypes.cs Normal file
View File

@@ -0,0 +1,39 @@
/*-------------------------------------------------------------------------
// UNCLASSIFIED
/*-------------------------------------------------------------------------
RAYTHEON PROPRIETARY: THIS DOCUMENT CONTAINS DATA OR INFORMATION
PROPRIETARY TO RAYTHEON COMPANY AND IS RESTRICTED TO USE ONLY BY PERSONS
AUTHORIZED BY RAYTHEON COMPANY IN WRITING TO USE IT. DISCLOSURE TO
UNAUTHORIZED PERSONS WOULD LIKELY CAUSE SUBSTANTIAL COMPETITIVE HARM TO
RAYTHEON COMPANY'S BUSINESS POSITION. NEITHER SAID DOCUMENT NOR ITS
CONTENTS SHALL BE FURNISHED OR DISCLOSED TO OR COPIED OR USED BY PERSONS
OUTSIDE RAYTHEON COMPANY WITHOUT THE EXPRESS WRITTEN APPROVAL OF RAYTHEON
COMPANY.
THIS PROPRIETARY NOTICE IS NOT APPLICABLE IF DELIVERED TO THE U.S.
GOVERNMENT.
UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
-------------------------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ProgramLib
{
/// <summary>
/// Partial class... defines all the types that this class needs
/// </summary>
internal partial class EventManager
{
public enum Events
{
GLOBAL_QUIT,
UUT_POWER_ON,
UUT_POWER_OFF,
FATAL_FAILURE
}
}
}

70
Source/Program/Common/Misc/EventManager.cs Normal file
View File

@@ -0,0 +1,70 @@
/*-------------------------------------------------------------------------
// UNCLASSIFIED
/*-------------------------------------------------------------------------
RAYTHEON PROPRIETARY: THIS DOCUMENT CONTAINS DATA OR INFORMATION
PROPRIETARY TO RAYTHEON COMPANY AND IS RESTRICTED TO USE ONLY BY PERSONS
AUTHORIZED BY RAYTHEON COMPANY IN WRITING TO USE IT. DISCLOSURE TO
UNAUTHORIZED PERSONS WOULD LIKELY CAUSE SUBSTANTIAL COMPETITIVE HARM TO
RAYTHEON COMPANY'S BUSINESS POSITION. NEITHER SAID DOCUMENT NOR ITS
CONTENTS SHALL BE FURNISHED OR DISCLOSED TO OR COPIED OR USED BY PERSONS
OUTSIDE RAYTHEON COMPANY WITHOUT THE EXPRESS WRITTEN APPROVAL OF RAYTHEON
COMPANY.
THIS PROPRIETARY NOTICE IS NOT APPLICABLE IF DELIVERED TO THE U.S.
GOVERNMENT.
UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
-------------------------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
namespace ProgramLib
{
/// <summary>
/// Stores global events that any thread can use to monitor
/// </summary>
internal partial class EventManager
{
private EventWaitHandle[] _events = new EventWaitHandle[Enum.GetValues(typeof(Events)).Cast<int>().Max() + 1];
// specify which event should have to be manually reset
List<Events> _manualEventList = new List<Events>
{
Events.GLOBAL_QUIT,
Events.FATAL_FAILURE
};
/// <summary>
/// The private constructor
/// </summary>
public EventManager()
{
for (int i = 0; i < _events.Count(); i++)
{
if (_manualEventList.Contains((Events)i))
{
_events[i] = new ManualResetEvent(false);
}
else
_events[i] = new AutoResetEvent(false);
}
}
/// <summary>
/// Implement Indexer to obtain an event object
/// </summary>
/// <param name=""></param>
/// <returns></returns>
public EventWaitHandle this[Events eventId]
{
get
{
return _events[(int)eventId];
}
}
}
}

46
Source/Program/Common/Misc/FileAndFolderManager.Datatypes.cs Normal file
View File

@@ -0,0 +1,46 @@
/*-------------------------------------------------------------------------
// UNCLASSIFIED
/*-------------------------------------------------------------------------
RAYTHEON PROPRIETARY: THIS DOCUMENT CONTAINS DATA OR INFORMATION
PROPRIETARY TO RAYTHEON COMPANY AND IS RESTRICTED TO USE ONLY BY PERSONS
AUTHORIZED BY RAYTHEON COMPANY IN WRITING TO USE IT. DISCLOSURE TO
UNAUTHORIZED PERSONS WOULD LIKELY CAUSE SUBSTANTIAL COMPETITIVE HARM TO
RAYTHEON COMPANY'S BUSINESS POSITION. NEITHER SAID DOCUMENT NOR ITS
CONTENTS SHALL BE FURNISHED OR DISCLOSED TO OR COPIED OR USED BY PERSONS
OUTSIDE RAYTHEON COMPANY WITHOUT THE EXPRESS WRITTEN APPROVAL OF RAYTHEON
COMPANY.
THIS PROPRIETARY NOTICE IS NOT APPLICABLE IF DELIVERED TO THE U.S.
GOVERNMENT.
UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
-------------------------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ProgramLib
{
/// <summary>
/// Partial class... defines all the types that this class needs
/// </summary>
internal partial class FileAndFolderManager
{
public enum Folders
{
// List data folder + its subfolders
DATA,
DATA_TEMP,
// List app folder + its folders
APP
}
public enum Files
{
POWER_SUPPLY_SELF_TEST_DATETIME
}
}
}

120
Source/Program/Common/Misc/FileAndFolderManager.cs Normal file
View File

@@ -0,0 +1,120 @@
/*-------------------------------------------------------------------------
// UNCLASSIFIED
/*-------------------------------------------------------------------------
RAYTHEON PROPRIETARY: THIS DOCUMENT CONTAINS DATA OR INFORMATION
PROPRIETARY TO RAYTHEON COMPANY AND IS RESTRICTED TO USE ONLY BY PERSONS
AUTHORIZED BY RAYTHEON COMPANY IN WRITING TO USE IT. DISCLOSURE TO
UNAUTHORIZED PERSONS WOULD LIKELY CAUSE SUBSTANTIAL COMPETITIVE HARM TO
RAYTHEON COMPANY'S BUSINESS POSITION. NEITHER SAID DOCUMENT NOR ITS
CONTENTS SHALL BE FURNISHED OR DISCLOSED TO OR COPIED OR USED BY PERSONS
OUTSIDE RAYTHEON COMPANY WITHOUT THE EXPRESS WRITTEN APPROVAL OF RAYTHEON
COMPANY.
THIS PROPRIETARY NOTICE IS NOT APPLICABLE IF DELIVERED TO THE U.S.
GOVERNMENT.
UNPUBLISHED WORK - COPYRIGHT RAYTHEON COMPANY.
-------------------------------------------------------------------------*/
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Raytheon.Common;
namespace ProgramLib
{
/// <summary>
/// Partial class... this is the main class responsible for parsing config.ini in order
/// to construct file paths and folder paths
/// </summary>
internal partial class FileAndFolderManager
{
private Dictionary<Folders, string> foldersDict = new Dictionary<Folders, string>();
private Dictionary<Files, string> filesDict = new Dictionary<Files, string>();
private IConfigurationFile _programConfig;
/// <summary>
/// The private constructor
/// </summary>
/// <param name="programConfig">the UUT part number</param>
public FileAndFolderManager(IConfigurationFile programConfig)
{
_programConfig = programConfig;
buildFolders();
createFolders();
buildFiles();
}
/// <summary>
/// Build folder paths so we can acccess them later
/// </summary>
/// <param name="iniObj"></param>
/// <returns></returns>
private void buildFolders()
{
string dataBasePath = _programConfig.ReadValue(ProgramConfigIni.GENERAL.ToString(), ProgramConfigIni.DATA_BASE_PATH.ToString(), "NOT SET");
foldersDict[Folders.DATA] = dataBasePath;
string val = _programConfig.ReadValue(ProgramConfigIni.GENERAL.ToString(), ProgramConfigIni.DATA_TEMP_PATH.ToString(), "NOT SET");
foldersDict[Folders.DATA_TEMP] = Path.Combine(dataBasePath, val);
string appBasePath = _programConfig.ReadValue(ProgramConfigIni.GENERAL.ToString(), ProgramConfigIni.APP_BASE_PATH.ToString(), "NOT SET");
foldersDict[Folders.APP] = dataBasePath;
}
/// <summary>
/// We create all the necessary folders
/// </summary>
/// <param name="iniObj"></param>
/// <returns></returns>
private void createFolders()
{
Directory.CreateDirectory(foldersDict[Folders.DATA_TEMP]);
}
/// <summary>
/// Build file paths so we can acccess them later
/// </summary>
/// <param name="iniObj"></param>
/// <returns></returns>
private void buildFiles()
{
string val = _programConfig.ReadValue(ProgramConfigIni.GENERAL.ToString(), ProgramConfigIni.POWER_SUPPLY_SELF_TEST_DATETIME.ToString(), "NOT SET");
filesDict[Files.POWER_SUPPLY_SELF_TEST_DATETIME] = Path.Combine(foldersDict[Folders.DATA_TEMP], val);
}
/// <summary>
/// Return the full folder path
/// </summary>
/// <param name="folder"></param>
/// <returns></returns>
public string getFolder(Folders folder)
{
if (foldersDict.ContainsKey(folder))
{
return foldersDict[folder];
}
else
throw new Exception($"{folder.ToString()} is invalid");
}
/// <summary>
/// Return the full file path
/// </summary>
/// <param name="iniObj"></param>
/// <returns></returns>
public string getFile(Files file)
{
if (filesDict.ContainsKey(file))
{
return filesDict[file];
}
else
throw new Exception($"{file.ToString()} is invalid");
}
}
}