/// <summary>
/// {@inheritDoc}
///
/// <para>This implementation first gets a list iterator that points to the end
/// of the list (with {@code listIterator(size())}). Then, it iterates
/// backwards over the list until the specified element is found, or the
/// beginning of the list is reached.
///
/// </para>
/// </summary>
/// <exception cref="ClassCastException"> {@inheritDoc} </exception>
/// <exception cref="NullPointerException"> {@inheritDoc} </exception>
public virtual int LastIndexOf(Object o)
{
ListIterator <E> it = ListIterator(Size());
if (o == null)
{
while (it.HasPrevious())
{
if (it.Previous() == null)
{
return(it.NextIndex());
}
}
}
else
{
while (it.HasPrevious())
{
if (o.Equals(it.Previous()))
{
return(it.NextIndex());
}
}
}
return(-1);
}
/// <exception cref="NBoilerpipe.BoilerpipeProcessingException"></exception>
public bool Process(TextDocument doc)
{
bool changes = false;
int words = 0;
IList <TextBlock> blocks = doc.GetTextBlocks();
if (!blocks.IsEmpty())
{
ListIterator <TextBlock> it = blocks.ListIterator <TextBlock>(blocks.Count);
TextBlock tb;
while (it.HasPrevious())
{
tb = it.Previous();
if (tb.HasLabel(DefaultLabels.INDICATES_END_OF_TEXT))
{
tb.AddLabel(DefaultLabels.STRICTLY_NOT_CONTENT);
tb.RemoveLabel(DefaultLabels.MIGHT_BE_CONTENT);
tb.SetIsContent(false);
changes = true;
}
else
{
if (tb.IsContent())
{
words += tb.GetNumWords();
if (words > 200)
{
break;
}
}
}
}
}
return(changes);
}
public void ForwardAndBackIteratorTest()
{
ExtendedOneWayLinkedListWithHead <int> lista = new ExtendedOneWayLinkedListWithHead <int>();
lista.Add(1);
lista.Add(2);
lista.Add(3);
List <int> actual = new List <int>();
ListIterator <int> iterator = lista.GetListIterator();
actual.Add(iterator.Next());
actual.Add(iterator.Next());
actual.Add(iterator.Previous());
actual.Add(iterator.Next());
actual.Add(iterator.Next());
while (iterator.HasPrevious())
{
actual.Add(iterator.Previous());
}
Assert.ThrowsException <System.IndexOutOfRangeException>(() => iterator.Previous());
List <int> lista2 = new List <int> {
1, 2, 2, 2, 3, 3, 2, 1
};
Assert.AreEqual(lista2.Count, actual.Count);
IEnumerator <int> iterator1 = actual.GetEnumerator();
IEnumerator <int> iterator2 = lista2.GetEnumerator();
while (iterator1.MoveNext() && iterator2.MoveNext())
{
Assert.AreEqual(iterator1.Current, iterator2.Current);
}
}
/// <returns>true, if the string currently being matched does match.</returns>
public virtual bool IsMatch()
{
ListIterator <Head> headIterator = heads.ListIterator(heads.Count);
while (headIterator.HasPrevious())
{
Head head = headIterator.Previous();
if (head == LastHead.INSTANCE)
{
return(true);
}
}
return(false);
}
/// <exception cref="NBoilerpipe.BoilerpipeProcessingException"></exception>
public bool Process(TextDocument doc)
{
IList <TextBlock> textBlocks = doc.GetTextBlocks();
if (textBlocks.Count < 2)
{
return(false);
}
int maxNumWords = -1;
TextBlock largestBlock = null;
int level = -1;
int i = 0;
int n = -1;
foreach (TextBlock tb in textBlocks)
{
if (tb.IsContent())
{
int nw = tb.GetNumWords();
if (nw > maxNumWords)
{
largestBlock = tb;
maxNumWords = nw;
n = i;
if (expandToSameLevelText)
{
level = tb.GetTagLevel();
}
}
}
i++;
}
foreach (TextBlock tb_1 in textBlocks)
{
if (tb_1 == largestBlock)
{
tb_1.SetIsContent(true);
}
else
{
tb_1.SetIsContent(false);
tb_1.AddLabel(DefaultLabels.MIGHT_BE_CONTENT);
}
}
if (expandToSameLevelText && n != -1)
{
for (ListIterator <TextBlock> it = textBlocks.ListIterator(n); it.HasPrevious();)
{
TextBlock tb_2 = it.Previous();
int tl = tb_2.GetTagLevel();
if (tl < level)
{
break;
}
else
{
if (tl == level)
{
tb_2.SetIsContent(true);
}
}
}
for (ListIterator <TextBlock> it_1 = textBlocks.ListIterator(n); it_1.HasNext();)
{
TextBlock tb_2 = it_1.Next();
int tl = tb_2.GetTagLevel();
if (tl < level)
{
break;
}
else
{
if (tl == level)
{
tb_2.SetIsContent(true);
}
}
}
}
return(true);
}
/// <exception cref="Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Reservation.Exceptions.PlanningException
/// "/>
/// <exception cref="Org.Apache.Hadoop.Yarn.Server.Resourcemanager.Reservation.Exceptions.ContractValidationException
/// "/>
private bool ComputeAllocation(ReservationId reservationId, string user, Plan plan
, ReservationDefinition contract, ReservationAllocation oldReservation)
{
Log.Info("placing the following ReservationRequest: " + contract);
Resource totalCapacity = plan.GetTotalCapacity();
// Here we can addd logic to adjust the ResourceDefinition to account for
// system "imperfections" (e.g., scheduling delays for large containers).
// Align with plan step conservatively (i.e., ceil arrival, and floor
// deadline)
long earliestStart = contract.GetArrival();
long step = plan.GetStep();
if (earliestStart % step != 0)
{
earliestStart = earliestStart + (step - (earliestStart % step));
}
long deadline = contract.GetDeadline() - contract.GetDeadline() % plan.GetStep();
// setup temporary variables to handle time-relations between stages and
// intermediate answers
long curDeadline = deadline;
long oldDeadline = -1;
IDictionary <ReservationInterval, ReservationRequest> allocations = new Dictionary
<ReservationInterval, ReservationRequest>();
RLESparseResourceAllocation tempAssigned = new RLESparseResourceAllocation(plan.GetResourceCalculator
(), plan.GetMinimumAllocation());
IList <ReservationRequest> stages = contract.GetReservationRequests().GetReservationResources
();
ReservationRequestInterpreter type = contract.GetReservationRequests().GetInterpreter
();
// Iterate the stages in backward from deadline
for (ListIterator <ReservationRequest> li = stages.ListIterator(stages.Count); li.
HasPrevious();)
{
ReservationRequest currentReservationStage = li.Previous();
// validate the RR respect basic constraints
ValidateInput(plan, currentReservationStage, totalCapacity);
// run allocation for a single stage
IDictionary <ReservationInterval, ReservationRequest> curAlloc = PlaceSingleStage(
plan, tempAssigned, currentReservationStage, earliestStart, curDeadline, oldReservation
, totalCapacity);
if (curAlloc == null)
{
// if we did not find an allocation for the currentReservationStage
// return null, unless the ReservationDefinition we are placing is of
// type ANY
if (type != ReservationRequestInterpreter.RAny)
{
throw new PlanningException("The GreedyAgent" + " couldn't find a valid allocation for your request"
);
}
else
{
continue;
}
}
else
{
// if we did find an allocation add it to the set of allocations
allocations.PutAll(curAlloc);
// if this request is of type ANY we are done searching (greedy)
// and can return the current allocation (break-out of the search)
if (type == ReservationRequestInterpreter.RAny)
{
break;
}
// if the request is of ORDER or ORDER_NO_GAP we constraint the next
// round of allocation to precede the current allocation, by setting
// curDeadline
if (type == ReservationRequestInterpreter.ROrder || type == ReservationRequestInterpreter
.ROrderNoGap)
{
curDeadline = FindEarliestTime(curAlloc.Keys);
// for ORDER_NO_GAP verify that the allocation found so far has no
// gap, return null otherwise (the greedy procedure failed to find a
// no-gap
// allocation)
if (type == ReservationRequestInterpreter.ROrderNoGap && oldDeadline > 0)
{
if (oldDeadline - FindLatestTime(curAlloc.Keys) > plan.GetStep())
{
throw new PlanningException("The GreedyAgent" + " couldn't find a valid allocation for your request"
);
}
}
// keep the variable oldDeadline pointing to the last deadline we
// found
oldDeadline = curDeadline;
}
}
}
// / If we got here is because we failed to find an allocation for the
// ReservationDefinition give-up and report failure to the user
if (allocations.IsEmpty())
{
throw new PlanningException("The GreedyAgent" + " couldn't find a valid allocation for your request"
);
}
// create reservation with above allocations if not null/empty
ReservationRequest ZeroRes = ReservationRequest.NewInstance(Resource.NewInstance(
0, 0), 0);
long firstStartTime = FindEarliestTime(allocations.Keys);
// add zero-padding from arrival up to the first non-null allocation
// to guarantee that the reservation exists starting at arrival
if (firstStartTime > earliestStart)
{
allocations[new ReservationInterval(earliestStart, firstStartTime)] = ZeroRes;
firstStartTime = earliestStart;
}
// consider to add trailing zeros at the end for simmetry
// Actually add/update the reservation in the plan.
// This is subject to validation as other agents might be placing
// in parallel and there might be sharing policies the agent is not
// aware off.
ReservationAllocation capReservation = new InMemoryReservationAllocation(reservationId
, contract, user, plan.GetQueueName(), firstStartTime, FindLatestTime(allocations
.Keys), allocations, plan.GetResourceCalculator(), plan.GetMinimumAllocation());
if (oldReservation != null)
{
return(plan.UpdateReservation(capReservation));
}
else
{
return(plan.AddReservation(capReservation));
}
}
internal virtual void Normalize()
{
for (ListIterator <ComparableVersion.Item> iterator = ListIterator(Count); iterator
.HasPrevious();)
{
ComparableVersion.Item item = iterator.Previous();
if (item.IsNull())
{
iterator.Remove();
}
else
{
// remove null trailing items: 0, "", empty list
break;
}
}
}
private void CompareListIterators(ListIterator it1, ListIterator it2)
{
while (it1.HasPrevious())
{
NUnit.Framework.Assert.AreEqual(it1.Previous(), it2.Previous());
}
NUnit.Framework.Assert.IsFalse(it2.HasPrevious());
CompareIterators(it1, it2);
}
/// <exception cref="NBoilerpipe.BoilerpipeProcessingException"></exception>
public bool Process(TextDocument doc)
{
IList <TextBlock> textBlocks = doc.GetTextBlocks();
if (textBlocks.Count < 2)
{
return(false);
}
bool changes = false;
int remaining = textBlocks.Count;
TextBlock blockBelow = null;
TextBlock block;
for (ListIterator <TextBlock> it = textBlocks.ListIterator <TextBlock>(textBlocks.Count); it.HasPrevious
();)
{
if (--remaining <= 0)
{
break;
}
if (blockBelow == null)
{
blockBelow = it.Previous();
continue;
}
block = it.Previous();
ICollection <string> labels = block.GetLabels();
if (labels != null && !labels.IsEmpty())
{
foreach (string l in labels)
{
blockBelow.AddLabel(labelPrefix + l);
}
changes = true;
}
blockBelow = block;
}
return(changes);
}
