//public static string CreatePrettyLabel(int length, LabelType type)
//{
// return New().CreatePrettyLabel_nonstatic(length, type);
//}
// ----------------------------------------------------------------------------------------
/// <!-- CreatePrettyLabel -->
/// <summary>
///
/// </summary>
/// <param name="length"></param>
/// <returns></returns>
public static string CreatePrettyLabel(int length, LabelType type)
{
// New();
string label;
switch (type)
{
case LabelType.name: label = "Jon Grover"; break; // DrawLabel(length, _rtNames); break;
case LabelType.place: label = "Indianapolis"; break; // DrawLabel(length, _rtPlaces); break;
case LabelType.word: label = "courage"; break; // DrawLabel(length, _rtWords); break;
default:
switch (RandomSource.New().Random.Next(3))
{
case 0: label = "Jon Grover"; break; // DrawLabel(length, _rtNames); break;
case 1: label = "Indianapolis"; break; // DrawLabel(length, _rtPlaces); break;
default: label = "courage"; break; // DrawLabel(length, _rtWords); break;
}
break;
}
return(label);
}
// ----------------------------------------------------------------------------------------
/// <!-- RandomCharacteristic -->
/// <summary>
///
/// </summary>
/// <returns></returns>
/// <remarks>production ready</remarks>
public char RandomCharacteristic()
{
Random r = RandomSource.New().Random;
List <char> key = new List <char>(_char.Keys);
return(key[r.Next(key.Count)]);
}
// ----------------------------------------------------------------------------------------
/// <!-- NiceName -->
/// <summary>
/// Returns a usable storage file name
/// </summary>
/// <param name="path"></param>
/// <returns></returns>
/// <remarks>beta code - used once in production</remarks>
public static string NiceName(string path)
{
int sectionLength = 8;
// --------------------------------------------------------------------------
// Name components
// --------------------------------------------------------------------------
string suffix = FilesIO.FileSuffix(path);
string body = FilesIO.ThinFileBody(path);
Random r = RandomSource.New().Random;
string num = r.Next(10000).ToString().PadLeft(4, '0');
// --------------------------------------------------------------------------
// Construct name
// --------------------------------------------------------------------------
string nice = "";
if (body.Length > sectionLength * 2)
{
string body1 = Regex.Replace(body, "^(.{" + sectionLength + "}).*$", "$1");
string body2 = Regex.Replace(body, "^.*(.{" + sectionLength + "})$", "$1");
nice = body1 + body2 + num + suffix;
}
else
{
nice = body + num + suffix;
}
return(nice);
}
// ----------------------------------------------------------------------------------------
/// <!-- StdDeviation -->
/// <summary>
///
/// </summary>
/// <param name="list"></param>
/// <returns></returns>
/// <remarks>alpha code</remarks>
//public static double StdDeviation(Dictionary<char, int> list)
//{
// double average = list.Values.Average();
// double sumOfDifferencesSquared = list.Select(val => ((double)val.Value - average) * ((double)val.Value - average)).Sum();
// double sd = Math.Sqrt(sumOfDifferencesSquared / list.Count);
// return sd;
//}
//public static double StdDeviation(List<double> list)
//{
// double average = list.Average();
// double sumOfDifferencesSquared = list.Select(val => ((double)val - average) * ((double)val - average)).Sum();
// double sd = Math.Sqrt(sumOfDifferencesSquared / list.Count);
// return sd;
//}
public static int XdY(int x, int y)
{
_r = RandomSource.New().Random;
int sum = 0;
for (int i = 0; i < x; ++i)
{
sum += D(y);
}
return(sum);
}
// ----------------------------------------------------------------------------------------
/// <!-- Nd6 -->
/// <summary>
///
/// </summary>
/// <param name="n"></param>
/// <returns></returns>
public static int Nd6(int n)
{
_r = RandomSource.New().Random;
int sum = 0;
for (int i = 0; i < n; ++i)
{
sum += D6;
}
return(sum);
}
// ----------------------------------------------------------------------------------------
// Constructors
// ----------------------------------------------------------------------------------------
//public Aspect(object sender, string conn, string root, int level)
//{
// Sender = sender;
// Root = root ;
// Level = level ;
// Method = new List<string>();
// Start = DateTime.Now.AddMilliseconds(-100);
// r = RandomSource.New().Random;
// InputConn = conn;
// OutputConn = conn;
// if (!string.IsNullOrEmpty(conn)) _inputConnection = new SqlConnection(conn);
// if (!string.IsNullOrEmpty(conn)) _outputConnection = new SqlConnection(conn);
//}
/// <summary>
/// Constructs a general purpose aspect
/// </summary>
/// <param name="project" >name of project</param>
/// <param name="sender" >this or sender</param>
/// <param name="primaryConn" >connection</param>
/// <param name="secondaryConn">maybe the same or different than the primaryConn</param>
/// <param name="root" >root or working directory</param>
/// <param name="level" >usually starts at 0</param>
public InfoAspect(string project, object sender, string primaryConn, string secondaryConn, string root = "", int level = 0)
{
Project = project;
Sender = sender;
Root = root;
Level = level;
Method = new List <string>();
Start = DateTime.Now.AddMilliseconds(-100);
r = RandomSource.New().Random;
PrimaryConn = primaryConn;
SecondaryConn = secondaryConn;
}
// ----------------------------------------------------------------------------------------
/// <!-- CreatePrettyLabel -->
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
protected override string CreatePrettyLabel(string name)
{
string data;
RandomSource rs = RandomSource.New();
//Random r = rs.Random;
string labelType = LblType(name); // encapsulate
switch (labelType)
{
case "name": data = DbLabels.CreatePrettyLabel(rs.Skew(1, 512), LabelType.name); break;
default: data = DbLabels.CreatePrettyLabel(rs.Skew(1, 512), LabelType.any); break;
}
return(data);
}
//// ----------------------------------------------------------------------------------------
///// <!-- Labels member and property -->
///// <remarks>
///// _labels is the resource that needs to be protected in this singleton
///// </remarks>
//DataSet _labels;
///// <summary>
///// Accesses the database label source
///// </summary>
//public DataSet Labels
//{
// get { return _labels; }
//}
// ----------------------------------------------------------------------------------------
/// <!-- CreateUglyLabel -->
/// <summary>
/// Creates a really ugly letter string including some caps and some spaces
/// </summary>
/// <param name="maxLength"></param>
/// <returns></returns>
public static string CreateUglyLabel(int lowLength, int highLength)
{
if (highLength == int.MaxValue)
{
highLength = int.MaxValue - 1;
}
Random r = RandomSource.New().Random;
string str = CreateUglyLabel(r.Next(1, highLength + 1));
for (int i = 0; str.Length < lowLength && i < 10; ++i)
{
str = CreateUglyLabel(r.Next(1, highLength + 1));
}
return(str);
}
// ----------------------------------------------------------------------------------------
/// <!-- DrawLetter -->
/// <summary>
/// Draws a character from the bag
/// </summary>
/// <returns></returns>
public char DrawLetter()
{
char c;
if (_bag.Count > 0)
{
Random r = RandomSource.New().Random;
int idx = r.Next(_bag.Count);
c = _bag[idx];
_bag.RemoveAt(idx);
}
else
{
c = ' ';
}
return(c);
}
// ----------------------------------------------------------------------------------------
/// <!-- CreateDate -->
/// <summary>
/// Creates a date string in one of these formats: 1999-05-31-05:00 1999-05-31Z
/// 1999-05-31 1999-05--
/// </summary>
/// <returns></returns>
/// <remarks>beta code - used once in production</remarks>
protected override string CreateDate(string name)
{
RandomSource rs = RandomSource.New();
int hoursOffset = rs.Skew(-1000, 1000);
DateTime time = DateTime.UtcNow.AddHours(hoursOffset);
Random r = rs.Random;
string data = "";
switch (r.Next(2))
{
// case 0 : data = time.ToString("yyyy-MM--") + CreateTimeZone(r); break;
default: data = time.ToString("yyyy-MM-dd") + CreateTimeZone(r); break;
}
return(data);
}
// ----------------------------------------------------------------------------------------
/// <!-- CreateDateTime -->
/// <summary>
/// One of the following formats:
/// 1999-05-31T13:20:00.01-05:00
/// +14:00..-14:00
/// 1999-05-31
/// 13:20:00-05:00
/// 1999-05
/// --05-17
/// ---15
/// --11--
/// </summary>
/// <returns></returns>
protected override string CreateDateTime(string name)
{
string data = "";
RandomSource rs = RandomSource.New();
DateTime dtm = DateTime.UtcNow.AddHours(rs.Skew(-100, 100));
Random r = rs.Random;
switch (r.Next(1))
{
case 0: data = dtm.ToString("yyyy-MM-ddTHH:mm:ss") + CreateTimeZone(r); break;
//case 1: data = dtm.ToString("yyyy-MM-dd") + CreateTimeZone(r); break;
//case 2: data = dtm.ToString("HH:mm:ss") + CreateTimeZone(r); break;
}
return(data);
}
// ----------------------------------------------------------------------------------------
/// <!-- CreateNumElements -->
/// <summary>
/// Comes up with a random number based on the minimum and maximum bounds for a node
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
protected override int CreateNumElements(RichXmlNode node)
{
if (node == null)
{
return(-999);
}
string minOccurs = node.Attribute("minOccurs"); // included minBound
string maxOccurs = node.Attribute("maxOccurs");
Random r = RandomSource.New().Random;
int minNum = 1;
int maxNum = 1;
int num = 1;
if (node.Attribute("name") == "PV2_26")
{
Pause();
}
// --------------------------------------------------------------------------
// Determine number of elements to create
// --------------------------------------------------------------------------
if (!string.IsNullOrEmpty(minOccurs))
{
minNum = _gen_.Integer(minOccurs, 0);
}
if (!string.IsNullOrEmpty(maxOccurs))
{
maxNum = _gen_.Integer(maxOccurs, minNum + r.Next(1, 4) * r.Next(0, 5));
}
num = r.Next(minNum, maxNum + 1);
// --------------------------------------------------------------------------
// If something strange happened...
// --------------------------------------------------------------------------
if (minNum > maxNum)
{
throw new ArithmeticException("XmlGenerator.NumElements error - min number greater than max number");
}
return(num);
}
// ----------------------------------------------------------------------------------------
// Constructors
// ----------------------------------------------------------------------------------------
//public Aspect(object sender, string conn, string root, int level)
//{
// Sender = sender;
// Root = root ;
// Level = level ;
// Method = new List<string>();
// Start = DateTime.Now.AddMilliseconds(-100);
// r = RandomSource.New().Random;
// InputConn = conn;
// OutputConn = conn;
// if (!string.IsNullOrEmpty(conn)) _inputConnection = new SqlConnection(conn);
// if (!string.IsNullOrEmpty(conn)) _outputConnection = new SqlConnection(conn);
//}
/// <summary>
///
/// </summary>
/// <param name="project" >name of project</param>
/// <param name="sender" >this or sender</param>
/// <param name="inputConn" >connection</param>
/// <param name="outputConn">maybe the same or different than the inputConn</param>
/// <param name="root" >root or working directory</param>
/// <param name="level" >usually starts at 0</param>
public InfoAspect(string project, object sender, string inputConn, string outputConn, string root, int level)
{
Project = project;
Sender = sender;
Root = root;
Level = level;
Method = new List <string>();
Start = DateTime.Now.AddMilliseconds(-100);
r = RandomSource.New().Random;
InputConn = inputConn; if (!string.IsNullOrEmpty(inputConn.Trim()))
{
_inputConnection = new SqlConnection(inputConn);
}
OutputConn = outputConn; if (!string.IsNullOrEmpty(outputConn.Trim()))
{
_outputConnection = new SqlConnection(outputConn);
}
}
// ----------------------------------------------------------------------------------------
/// <!-- CreateUglyLabel -->
/// <summary>
/// Creates a really ugly letter string including some caps and some spaces
/// </summary>
/// <param name="length"></param>
/// <returns></returns>
public static string CreateUglyLabel(int length)
{
Random r = RandomSource.New().Random;
string str = "";
for (int i = 0; i < length; ++i)
{
int num;
switch (r.Next(i + 1))
{
case 0: num = r.Next(65, 90); break;
case 4: num = 32; break;
case 10: num = 95; break;
default: num = r.Next(98, 123); break;
}
char cha = Convert.ToChar(num);
str += cha;
}
return(str);
}
// ----------------------------------------------------------------------------------------
/// <!-- SelectionBag -->
/// <summary>
/// Places a bunch of marbles (chars) in a bag for random selection
/// </summary>
/// <param name="size">number of marbles in bag (try a multiple of 8 <= 120)</param>
/// <returns></returns>
private List <char> SelectionBag(Endeme e, int size)
{
Random r = RandomSource.New().Random;
if (this.Count > this.OriginalCount)
{
throw new Exception("SelectionBag");
}
// ----------------------------------------------------------------
// Define number of each kind of marble (character)
// ----------------------------------------------------------------
char[] endeme = e.ToCharArray();
string str = "";
switch (size)
{
case 128: str = "@>=;:98765544332221111"; break;
case 120: str = "@><;987665443322221111"; break;
case 112: str = "?=;:987654433322211111"; break;
case 104: str = "><:9876654433222211111"; break;
case 96: str = "=;:9776544333222111110"; break;
case 88: str = "<:98765544332221111110"; break;
case 80: str = ";987665443322221111110"; break;
case 72: str = ":877654433322211111100"; break;
case 64: str = "9876544333222111111000"; break;
case 60: str = "8766544332222111111000"; break;
case 56: str = "8765543332221111110000"; break;
case 52: str = "7665443322221111110000"; break;
case 48: str = "7655433322211111100000"; break;
case 44: str = "6554433222211111100000"; break;
case 40: str = "6544333222111111000000"; break;
case 36: str = "5544332221111110000000"; break;
case 32: str = "5433322221111110000000"; break;
case 28: str = "4433222211111100000000"; break;
case 24: str = "4332222111111000000000"; break;
case 20: str = "3322221111110000000000"; break;
case 16: str = "3222111111100000000000"; break;
case 14: str = "2222111111000000000000"; break;
case 12: str = "2221111110000000000000"; break;
case 10: str = "2211111100000000000000"; break;
case 8: str = "2111111000000000000000"; break;
case 7: str = "2111110000000000000000"; break;
case 6: str = "1111110000000000000000"; break;
case 5: str = "1111100000000000000000"; break;
case 4: str = "1111000000000000000000"; break;
case 3: str = "1110000000000000000000"; break;
case 2: str = "1100000000000000000000"; break;
case 1: str = "1000000000000000000000"; break;
default: str = "";
Dictionary <char, int> cha = new Dictionary <char, int>(22);
foreach (char c in endeme)
{
cha.Add(c, 0);
}
for (int i = 0; i < size; ++i)
{
cha[e.RandomLetter(0.89)]++;
}
var query = from ch in cha orderby cha.Values descending select cha;
str = "";
foreach (var item in query)
{
str = str + item.ToString();
}
break; // TODO: build the function that approximates these series (.89 * one before)
}
// ----------------------------------------------------------------
// Put marbles (characters) in bag
// ----------------------------------------------------------------
List <int> quantity = StringToNums(str);
List <char> bag = new List <char>(size);
for (int i = 0; i < quantity.Count; ++i)
{
for (int j = 0; j < quantity[i]; ++j)
{
if (i < endeme.Length)
{
bag.Add(endeme[i]);
}
else if (endeme.Length > 0)
{
bag.Add(endeme[0]);
}
}
}
return(bag);
}
public Endeme RandomEndeme()
{
return(RandomEndeme(RandomSource.New().Random));
}
// ----------------------------------------------------------------------------------------
/// <!-- CreateString -->
/// <summary>
/// Creates a string to meet a particular set of restrictions
/// </summary>
/// <param name="cmd"></param>
/// <param name="name"></param>
/// <returns></returns>
protected override string CreateString(NodeCreationCommand cmd, string name)
{
string str = "";
if (Regex.IsMatch(name, "amount", RegexOptions.IgnoreCase))
{
Pause();
}
// --------------------------------------------------------------------------
// Use the restrictions (new <--> now)
// --------------------------------------------------------------------------
RandomSource rs = RandomSource.New();
Random r = rs.Random;
if (cmd.Enumerations != null && cmd.Enumerations.Count > 0)
{
int e = r.Next(cmd.Enumerations.Count);
str = cmd.Enumerations[e];
}
else
{
switch (cmd.MaxLength)
{
case -1: // encapsulate
if (string.IsNullOrEmpty(cmd.RegexPattern))
{
bool found = false; // encapsulate
if (!found && IsNumericField(name))
{
found = true; str = new RegexGenerator("[0-9]").CreateString(r, rs.Skew(1, 49), cmd.WhiteSpace);
}
if (!found && IsDateTime(name))
{
found = true; str = CreateDateTime(name);
}
if (!found)
{
str = CreatePrettyLabel(name); // encapsulate
}
}
else
{
bool found = false;
if (IsNumericField(name)) // encapsulate
{
str = new RegexGenerator(cmd.RegexPattern).CreateString(r, rs.Skew(7, 50), cmd.WhiteSpace);
found = true;
}
if (IsDigitField(name)) // encapsulate
{
str = new RegexGenerator(cmd.RegexPattern).CreateString(r, 1, cmd.WhiteSpace);
found = true;
}
if (!found)
{
str = new RegexGenerator(cmd.RegexPattern).CreateString(r, cmd.WhiteSpace);
}
}
break;
case 0: str = ""; break;
default:
if (!string.IsNullOrEmpty(cmd.RegexPattern))
{
// ----------------------------------------------------------
// convert a Regex pattern into a random string that it will match
// ----------------------------------------------------------
RegexGenerator genRegex = new RegexGenerator(cmd.RegexPattern);
str = genRegex.CreateString(r, cmd.WhiteSpace);
for (int i = 0; str.Length > cmd.MaxLength && i < 10; i++)
{
str = genRegex.CreateString(r, cmd.WhiteSpace);
}
}
else // encapsulate
{
str = DbLabels.CreatePrettyLabel(r.Next(1, cmd.MaxLength + 1), LabelType.any);
}
break;
}
}
return(str);
}
private static void Init()
{
_r = RandomSource.New().Random;
}
