internal static SequenceType Create(XmlSchemaType schemaType, Occurence occurence)
{
switch (schemaType.QualifiedName.Namespace)
{
case XmlSchema.Namespace:
case InternalPool.XdtNamespace:
break;
default:
return(new SequenceType(schemaType, occurence));
}
Hashtable cacheForType = standardTypes [schemaType] as Hashtable;
if (cacheForType == null)
{
cacheForType = new Hashtable();
standardTypes [schemaType] = cacheForType;
}
else
{
SequenceType type = cacheForType [occurence] as SequenceType;
if (type != null)
{
return(type);
}
}
SequenceType t = new SequenceType(schemaType, occurence);
cacheForType [occurence] = t;
return(t);
}
public HolidayRule(Occurence occurence, DayOfWeek dayOfWeek, int month)
{
Occurence = occurence;
DayOfWeek = dayOfWeek;
Month = month;
HolidayType = HolidayType.Dynamic;
}
//this shit is to make Ben happy with his stupid probabilities
public static void CountOccurenceOfLetterInSentence(string inputLine)
{
string[] words = inputLine.Split(' ');
List <Occurence> letters = new List <Occurence>();
foreach (var w in words)
{
char[] ls = w.ToCharArray();
foreach (char c in ls)
{
Occurence o = new Occurence(c);
if (letters.Contains(o))
{
letters.Where(l => l.letter == o.letter).First().IncrementCount();
}
else
{
letters.Add(o);
}
}
}
foreach (Occurence o in letters.OrderBy(le => le.count))
{
Console.WriteLine(o.PrintContents());
}
Console.WriteLine("The line contained: " + inputLine.Length + " letters.");
}
public async Task <ActionResult <Occurence> > PostOccurence(Occurence occurence)
{
_context.occurence.Add(occurence);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetOccurence", new { id = occurence.Id }, occurence));
}
public Effect(Type type, Value on, Occurence occur, double factor)
{
this.type = type;
this.value = on;
this.occur = occur;
this.factor = factor;
}
Dictionary <int, Occurence> FindOccurences(int[] nums)
{
var result = new Dictionary <int, Occurence>();
for (int i = 0; i < nums.Length; i++)
{
Occurence occurence;
if (!result.ContainsKey(nums[i]))
{
occurence = new Occurence
{
Amount = 0,
Left = i,
Right = -1
};
result.Add(nums[i], occurence);
}
else
{
occurence = result[nums[i]];
}
occurence.Amount++;
occurence.Right = i;
}
return(result);
}
public async Task <IActionResult> PutOccurence(int id, Occurence occurence)
{
if (id != occurence.Id)
{
return(BadRequest());
}
_context.Entry(occurence).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!OccurenceExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public Cycle(GameObjectCycle gOCycle)
{
this.occurence = gOCycle.occurence.GetComponent <Occurence>();
this.positiveGratification = gOCycle.positiveGratification.GetComponent <Gratification>();
this.negativeGratification = gOCycle.negativeGratification.GetComponent <Gratification>();
this.culmination = gOCycle.culmination.GetComponent <Culmination>();
}
public int FindShortestSubArray(int[] nums)
{
var occurences = FindOccurences(nums);
var degree = 0;
Occurence resultOccurence = null;
foreach (var occurence in occurences)
{
if (resultOccurence == null)
{
resultOccurence = occurence.Value;
continue;
}
if (occurence.Value.Amount > resultOccurence.Amount)
{
resultOccurence = occurence.Value;
continue;
}
if (occurence.Value.Amount == resultOccurence.Amount)
{
if (occurence.Value.Right - occurence.Value.Left + 1 <
resultOccurence.Right - resultOccurence.Left + 1)
{
resultOccurence = occurence.Value;
}
}
}
return(resultOccurence.Right - resultOccurence.Left + 1);
}
public void TestContainsForNonExistant()
{
var fingerPrint = new FingerPrint("Boobs");
var occ = new Occurence('v', 1);
Assert.AreEqual(false, fingerPrint.Contains(occ));
}
public void TestContainsTrue()
{
var fingerPrint = new FingerPrint("Boobs");
var occ = new Occurence('o', 2);
Assert.AreEqual(true, fingerPrint.Contains(occ));
}
private void ProcessNewModule(Occurence <ModuleRegistration> validModule)
{
var moduleName = validModule.Key.Name;
var fUnit = new FileCompilationUnit <ModuleRegistration>(FilePath(), validModule.Key);
if (RefTable.Instance.HasDuplicates(moduleName))
{
_modulePool.Request(fUnit);
ModuleHub.Instance.ModuleDuplicated(moduleName);
return;
}
//_modulePool.Request(fUnit);
if (validModule.Occurences.Count == 1)
{
var newModule = _modulePool.Request(
fUnit,
validModule.Key.ClassRegistrations.ToViewModels(),
validModule.Key.ModuleRegistrations.CollectSubModules());
ModuleHub.Instance.ModuleCreated(newModule);
}
else
{
ModuleHub.Instance.ModuleDuplicated(moduleName);
}
}
public ActionResult DeleteConfirmed(int id)
{
Occurence occurence = db.Occurences.Find(id);
db.Occurences.Remove(occurence);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public void AreEqualtotheInputkeyvalue()
{
char[] input = "aaabbcdffffffffffffhhhhhhhh".ToCharArray();
Occurence _occurence = new Occurence(input);
_occurence.CountOccurenceorderoflogN(0, input.Length - 1);
Assert.AreEqual(_occurence.dict['f'], 12);
}
public void AreEqualtotheInputkeyvalueorderofN_large()
{
char[] input = "aaabbcdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz".ToCharArray();
Occurence _occurence = new Occurence(input);
_occurence.CountOccurenceOrderofN(0, input.Length - 1);
Assert.AreEqual(_occurence.dict['a'], 3);
}
/// <summary>
/// Replaces the top level predicate to a new LogicalPredicate that
/// contains the original top level predicate and a given predicate
/// encapsulated by two individual LogicalClause with the given occurence.
/// </summary>
public void AddClause(SnQueryPredicate clause, Occurence occurence)
{
QueryTree = new LogicalPredicate(new[]
{
new LogicalClause(QueryTree, occurence),
new LogicalClause(clause, occurence),
});
}
public ActionResult Edit([Bind(Include = "OccurenceID,OccurenceName,OccurenceCategory,OccurenceDate")] Occurence occurence)
{
if (ModelState.IsValid)
{
db.Entry(occurence).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(occurence));
}
public ActionResult Create([Bind(Include = "OccurenceID,OccurenceName,OccurenceCategory,OccurenceDate")] Occurence occurence)
{
if (ModelState.IsValid)
{
db.Occurences.Add(occurence);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(occurence));
}
public Defect(int id, string device, string title, string supplier, DateTime date,
Status status, Priority priority, Occurence occurence)
{
this.Defectid = id;
this.defectdevice = device;
this.Defectitle = title;
this.Defectsupplier = supplier;
this.Defectdate = date;
this.enum_defectoccurence = occurence;
this.enum_defectpriority = priority;
this.enum_defectstatus = status;
}
// GET: /Occurence/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Occurence occurence = db.Occurences.Find(id);
if (occurence == null)
{
return(HttpNotFound());
}
return(View(occurence));
}
/// <summary>
/// Creates task from occurence
/// </summary>
/// <param name="occurence"> occurence of defect</param>
/// <param name="fileName">file name of occurence</param>
/// <returns></returns>
Task CreateTask(Occurence occurence, string fileName)
{
var defectTask = new ErrorTask()
{
Category = TaskCategory.User,
ErrorCategory = TaskErrorCategory.Warning,
CanDelete = false,
Text = occurence.Message,
Document = fileName,
Line = int.Parse(occurence.StartLine)
};
defectTask.Navigate += navigateEventHandler;
return(defectTask);
}
private IEnumerable <Occurence> GenerateRuleViolationOccurences(IEnumerable <SyntaxNode> syntaxNode, Document document)
{
var tree = document.GetSyntaxTreeAsync().Result;
foreach (var node in syntaxNode)
{
var occ = new Occurence()
{
File = document.FilePath,
Line = tree.GetLineSpan(node.FullSpan).ToString().Split(' ').Last(),
CodeFragment = node.ToString().Length > 100 ? node.ToString().Substring(0, 100) : node.ToString()
};
yield return(occ);
}
}
// ======================================================================
private BooleanClause.Occur CompileOccur(Occurence occur)
{
switch (occur)
{
case Occurence.Default:
case Occurence.Should: return(BooleanClause.Occur.SHOULD);
case Occurence.Must: return(BooleanClause.Occur.MUST);
case Occurence.MustNot: return(BooleanClause.Occur.MUST_NOT);
default:
throw new ArgumentOutOfRangeException(nameof(occur), occur, null);
}
}
/// <summary>
/// Creates task from occurence
/// </summary>
/// <param name="occurence"> occurence of defect</param>
/// <param name="fileName">file name of occurence</param>
/// <returns></returns>
Task CreateTask(Occurence occurence, string fileName)
{
var defectTask = new ErrorTask()
{
Category = TaskCategory.User,
ErrorCategory = TaskErrorCategory.Warning,
CanDelete = false,
Text = occurence.Message,
Document = fileName,
Line = int.Parse(occurence.StartLine) - 1 //XXX There must be '- 1' because Dexter points to defect at one line ahead
};
defectTask.Navigate += navigateEventHandler;
return(defectTask);
}
internal Occurence ToOccurence()
{
Occurence occurence = new Occurence();
occurence.StartLine = StartLine;
occurence.EndLine = EndLine;
occurence.FieldName = FieldName;
occurence.CharStart = CharStart;
occurence.CharEnd = CharEnd;
occurence.Message = Message;
occurence.StringValue = StringValue;
occurence.VariableName = VariableName;
occurence.Code = OccurenceCode;
return(occurence);
}
private bool OccursAreEqual(Occurence occur1, Occurence occur2)
{
// the most common case returns first
if (occur1 == occur2)
{
return(true);
}
// pay attention to the default
if (occur1 == Occurence.Default || occur1 == Occurence.Should)
{
return(occur2 == Occurence.Default || occur2 == Occurence.Should);
}
return(false);
}
private static DateTime GetNthDay(int year, int month, DayOfWeek dayOfWeek, Occurence occurence)
{
var result = new DateTime(year, month, 1);
if (result.DayOfWeek != dayOfWeek)
{
var dayDifference = dayOfWeek - result.DayOfWeek;
dayDifference = dayDifference > 0 ? dayDifference : 7 + dayDifference;
result = result.AddDays(dayDifference);
}
if (occurence > Occurence.First)
{
result = result.AddDays(7 * (int)occurence);
}
return(result);
}
public void SetDominant([InjectGroup] Group group, string name, decimal?value)
{
if (!value.HasValue)
{
group.GetOrCreateValue <decimal>(name);
return;
}
var dict = group.GetOrCreateValue(name, new SortedDictionary <decimal, Occurence>());
if (!dict.TryGetValue(value.Value, out var occur))
{
occur = new Occurence();
dict.Add(value.Value, occur);
}
occur.Increment();
}
public void Add(string annotationName, string clipName, float startTime, float duration)
{
Occurence occurence = new Occurence()
{
clipName = clipName,
startTime = startTime,
duration = duration
};
List <Occurence> occurencesList;
if (!annotations.TryGetValue(annotationName, out occurencesList))
{
occurencesList = new List <Occurence>();
}
occurencesList.Add(occurence);
annotations[annotationName] = occurencesList;
}
internal static SequenceType Create(XmlTypeCode typeCode, Occurence occurence)
{
switch (typeCode)
{
case XmlTypeCode.Item:
case XmlTypeCode.AnyAtomicType:
case XmlTypeCode.Node:
case XmlTypeCode.Document:
case XmlTypeCode.Element:
case XmlTypeCode.Attribute:
case XmlTypeCode.ProcessingInstruction:
case XmlTypeCode.Comment:
case XmlTypeCode.Namespace:
case XmlTypeCode.Text:
return(new SequenceType(new ItemType(typeCode), occurence));
default:
return(Create(XmlSchemaType.GetBuiltInSimpleType(typeCode), occurence));
}
}
// Instance members
private SequenceType (XmlSchemaType schemaType, Occurence occurence)
{
this.schemaType = schemaType;
this.itemType = ItemType.AnyItem;
this.occurence = occurence;
}
public bool Equals(Occurence occurence)
{
return occurence._occurrence.Equals(_occurrence);
}
internal static SequenceType Create (XmlTypeCode typeCode, Occurence occurence)
{
switch (typeCode) {
case XmlTypeCode.Item:
case XmlTypeCode.AnyAtomicType:
case XmlTypeCode.Node:
case XmlTypeCode.Document:
case XmlTypeCode.Element:
case XmlTypeCode.Attribute:
case XmlTypeCode.ProcessingInstruction:
case XmlTypeCode.Comment:
case XmlTypeCode.Namespace:
case XmlTypeCode.Text:
return new SequenceType (new ItemType (typeCode), occurence);
default:
return Create (XmlSchemaType.GetBuiltInSimpleType (typeCode), occurence);
}
}
internal static SequenceType Create (XmlSchemaType schemaType, Occurence occurence)
{
switch (schemaType.QualifiedName.Namespace) {
case XmlSchema.Namespace:
case InternalPool.XdtNamespace:
break;
default:
return new SequenceType (schemaType, occurence);
}
Hashtable cacheForType = standardTypes [schemaType] as Hashtable;
if (cacheForType == null) {
cacheForType = new Hashtable ();
standardTypes [schemaType] = cacheForType;
} else {
SequenceType type = cacheForType [occurence] as SequenceType;
if (type != null)
return type;
}
SequenceType t = new SequenceType (schemaType, occurence);
cacheForType [occurence] = t;
return t;
}
internal SequenceType (ItemType itemType, Occurence occurence)
{
this.schemaType = InternalPool.XsAnyType;
this.itemType = itemType;
this.occurence = occurence;
}
