private static void DontModifyInner()
{
Console.WriteLine("\nMake a snapshot and add it to outer");
ICollection<ISequenced<int>> outer = new HashSet<ISequenced<int>>();
for (int i = 0; i < 100; i++)
{
ISequenced<int> inner = new TreeSet<int>();
inner.Add(i); inner.Add(i + 1);
outer.Add(inner);
}
IPersistentSorted<int>
inner1 = new TreeSet<int>(),
inner2 = new TreeSet<int>(),
inner3 = new TreeSet<int>();
inner1.AddAll(new[] { 2, 3, 5, 7, 11 });
inner2.AddAll(inner1); inner2.Add(13);
inner3.AddAll(inner1);
// Take a snapshot and add it to outer:
outer.Add(inner1.Snapshot());
Console.WriteLine("inner1 in outer: {0}", outer.Contains(inner1));
Console.WriteLine("inner2 in outer: {0}", outer.Contains(inner2));
Console.WriteLine("inner3 in outer: {0}", outer.Contains(inner3));
inner1.Add(13);
Console.WriteLine("inner1 equals inner2: {0}",
outer.EqualityComparer.Equals(inner1, inner2));
Console.WriteLine("inner1 equals inner3: {0}",
outer.EqualityComparer.Equals(inner1, inner3));
Console.WriteLine("inner1 in outer: {0}", outer.Contains(inner1));
Console.WriteLine("inner2 in outer: {0}", outer.Contains(inner2));
Console.WriteLine("inner3 in outer: {0}", outer.Contains(inner3));
Console.WriteLine("outer.Count: {0}", outer.Count);
}
// Anti-pattern: modifying an inner collection while it is a
// member of an outer one may cause it to be lost from the outer
// collection.
private static void ModifyInner()
{
Console.WriteLine("\nAnti-pattern: Add to outer, modify, lose");
ICollection<ISequenced<int>> outer = new HashSet<ISequenced<int>>();
for (int i = 0; i < 100; i++)
{
ISequenced<int> inner = new TreeSet<int>();
inner.Add(i); inner.Add(i + 1);
outer.Add(inner);
}
ISequenced<int>
inner1 = new TreeSet<int>(),
inner2 = new TreeSet<int>(),
inner3 = new TreeSet<int>();
inner1.AddAll(new[] { 2, 3, 5, 7, 11 });
inner2.AddAll(inner1); inner2.Add(13);
inner3.AddAll(inner1);
outer.Add(inner1);
Console.WriteLine("inner1 in outer: {0}", outer.Contains(inner1));
Console.WriteLine("inner2 in outer: {0}", outer.Contains(inner2));
Console.WriteLine("inner3 in outer: {0}", outer.Contains(inner3));
inner1.Add(13);
Console.WriteLine("inner1 equals inner2: {0}",
outer.EqualityComparer.Equals(inner1, inner2));
Console.WriteLine("inner1 equals inner3: {0}",
outer.EqualityComparer.Equals(inner1, inner3));
Console.WriteLine("inner1 in outer: {0}", outer.Contains(inner1));
Console.WriteLine("inner2 in outer: {0}", outer.Contains(inner2));
Console.WriteLine("inner3 in outer: {0}", outer.Contains(inner3));
Console.WriteLine("outer.Count: {0}", outer.Count);
}
public void testCollection()
{
List<String> data = new TreeSet<String>();
data.Add("foo");
data.Add("bar");
data.Add("baz");
Assert.AreEqual(TEST_DATA, IteratorUtils.iterableToList(data));
}
public IGeometry Union()
{
PointLocator locater = new PointLocator();
// use a set to eliminate duplicates, as required for union
#if Goletas
HashSet<ICoordinate> exteriorCoords = new HashSet<ICoordinate>();
#else
TreeSet exteriorCoords = new TreeSet();
#endif
foreach (IPoint point in PointExtracter.GetPoints(_pointGeom))
{
ICoordinate coord = point.Coordinate;
Locations loc = locater.Locate(coord, _otherGeom);
if (loc == Locations.Exterior)
{
exteriorCoords.Add(coord);
}
}
// if no points are in exterior, return the other geom
if (exteriorCoords.Count == 0)
{
return _otherGeom;
}
// make a puntal geometry of appropriate size
IGeometry ptComp = null;
ICoordinateSequence coords = _geomFact.CoordinateSequenceFactory.Create(exteriorCoords.ToArray());
ptComp = coords.Count == 1 ? (IGeometry)_geomFact.CreatePoint(coords.GetCoordinate(0)) : _geomFact.CreateMultiPoint(coords);
// add point component to the other geometry
return GeometryCombiner.Combine(ptComp, _otherGeom);
}
public static void IntSetSet()
{
ICollection<ISequenced<int>> outer = new HashSet<ISequenced<int>>();
int[] ss = { 2, 3, 5, 7 };
TreeSet<int> inner = new TreeSet<int>();
outer.Add(inner.Snapshot());
foreach (int i in ss)
{
inner.Add(i);
outer.Add(inner.Snapshot());
}
foreach (ISequenced<int> s in outer)
{
int sum = 0;
s.Apply(delegate(int x) { sum += x; });
Console.WriteLine("Set has {0} elements and sum {1}", s.Count, sum);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Option"/> class.
/// </summary>
/// <param name="attribute">The attribute describing this option.</param>
/// <param name="memberInfo">The <see cref="MemberInfo"/> object pointing to the member to which the attribute was applied.</param>
/// <param name="cmdLineObject">The command line manager object.</param>
/// <param name="optionGroups">A complete list of all available option groups.</param>
/// <param name="numberFormatInfo">The number format info to use for parsing numerical arguments.</param>
public Option(CommandLineOptionAttribute attribute, MemberInfo memberInfo, object cmdLineObject,
ICollection<OptionGroup> optionGroups, NumberFormatInfo numberFormatInfo)
{
mObject = cmdLineObject;
mMember = memberInfo;
mUsage = attribute.BoolFunction;
mDescription = attribute.Description;
mNumberFormatInfo = numberFormatInfo ?? CultureInfo.CurrentCulture.NumberFormat;
mDefaultValue = attribute.DefaultAssignmentValue;
mMinValue = attribute.MinValue;
mMaxValue = attribute.MaxValue;
// Check the validity of the member for which this attribute was defined
switch (memberInfo.MemberType)
{
case MemberTypes.Field:
FieldInfo fieldInfo = (FieldInfo)memberInfo;
if (fieldInfo.IsInitOnly || fieldInfo.IsLiteral)
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal field for this attribute; field must be writeable");
mOptionType = fieldInfo.FieldType;
break;
case MemberTypes.Method:
MethodInfo method = (MethodInfo)memberInfo;
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length != 1)
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal method for this attribute; the method must accept exactly one parameter");
if (parameters[0].IsOut)
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal method for this attribute; the parameter of the method must not be an out parameter");
if (IsArray(parameters[0].ParameterType) || IsCollectionType(parameters[0].ParameterType))
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal method for this attribute; the parameter of the method must be a non-array and non-collection type");
mOptionType = parameters[0].ParameterType;
break;
case MemberTypes.Property:
PropertyInfo propInfo = (PropertyInfo)memberInfo;
if (!propInfo.CanWrite && !IsCollectionType(propInfo.PropertyType))
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal property for this attribute; property for non-collection type must be writable");
if (!propInfo.CanRead && IsCollectionType(propInfo.PropertyType))
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal property for this attribute; property for collection type must be readable");
if (!(propInfo.CanRead && propInfo.CanWrite) && IsArray(propInfo.PropertyType))
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal property for this attribute; property representing array type must be both readable and writeable");
mOptionType = propInfo.PropertyType;
break;
default:
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal member for this attribute; member must be a property, method (accepting one parameter) or a field");
}
mMinOccurs = attribute.MinOccurs;
// MaxOccurs does not have a default value (since this is different for various types), so we set it here.
if (!attribute.IsMaxOccursSet)
{
// Use default setting for MaxOccurs
if (IsArray(mOptionType) || IsCollectionType(mOptionType))
mMaxOccurs = 0; // Unlimited
else
mMaxOccurs = 1;
}
else
{
mMaxOccurs = attribute.MaxOccurs;
}
if (mMinOccurs > mMaxOccurs && mMaxOccurs > 0)
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
String.Format(CultureInfo.CurrentUICulture, "MinOccurs ({0}) must not be larger than MaxOccurs ({1})", mMinOccurs, mMaxOccurs));
if (mMaxOccurs != 1 && !(IsArray(mOptionType) || IsCollectionType(mOptionType)) && mMember.MemberType != MemberTypes.Method)
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Invalid cardinality for member; MaxOccurs must be equal to one (1) for any non-array or non-collection type");
CommandLineManagerAttribute objectAttr = (CommandLineManagerAttribute)Attribute.GetCustomAttribute(mObject.GetType(), typeof(CommandLineManagerAttribute));
if (objectAttr == null)
throw new AttributeException(String.Format(CultureInfo.CurrentUICulture,
"Class {0} contains a CommandLineOptionAttribute, but does not have the attribute CommandLineObjectAttribute", mObject.GetType().FullName));
// Assign the name of this option from the member itself if no name is explicitly provided
if (attribute.Name == null)
{
mName = memberInfo.Name;
}
else
{
mName = attribute.Name;
}
// Find the group (if any) that this option belongs to in the list of available option groups
if (attribute.GroupId != null)
{
if (!optionGroups.Find(new Fun<OptionGroup, bool>(
delegate(OptionGroup searchGroup)
{
return attribute.GroupId.Equals(searchGroup.Id);
}), out mGroup))
{
throw new LogicException(String.Format(CultureInfo.CurrentUICulture, "Undefined group {0} referenced from member {1} in {2}", attribute.GroupId, memberInfo.Name, cmdLineObject.GetType().FullName));
}
mGroup.Options.Add(mName, this);
}
// Recursively find out if this option requires explicit assignment
if (attribute.DoesRequireExplicitAssignment.HasValue)
{
mRequireExplicitAssignment = attribute.DoesRequireExplicitAssignment.Value;
}
else if (mGroup != null)
{
mRequireExplicitAssignment = mGroup.RequireExplicitAssignment;
}
else
{
mRequireExplicitAssignment = objectAttr.RequireExplicitAssignment;
}
// Make sure the type of the field, property or method is supported
if (!IsTypeSupported(mOptionType))
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"Unsupported type for command line option.");
// Make sure MinValue and MaxValue is not specified for any non-numerical type.
if (mMinValue != null || mMaxValue != null)
{
if (!IsNumericalType)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"MinValue and MaxValue must not be specified for a non-numerical type");
}
else if (!mMinValue.GetType().IsAssignableFrom(GetBaseType(mOptionType)))
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"Illegal value for MinValue or MaxValue, not the same type as option");
}
}
// Some special checks for numerical types
if (IsNumericalType)
{
// Assign the default MinValue if it was not set and this is a numerical type
if (IsNumericalType && mMinValue == null)
{
mMinValue = GetBaseType(mOptionType).GetField("MinValue", BindingFlags.Static | BindingFlags.Public).GetValue(null);
}
// Assign the defaul MaxValue if it was not set and this is a numerical type
if (IsNumericalType && mMaxValue == null)
{
mMaxValue = GetBaseType(mOptionType).GetField("MaxValue", BindingFlags.Static | BindingFlags.Public).GetValue(null);
}
// Check that MinValue <= MaxValue
if (IsNumericalType && ((IComparable)MinValue).CompareTo(MaxValue) > 0)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"MinValue must not be greater than MaxValue");
}
}
// Check that the DefaultValue is not set if the option does not require explicit assignment.
// If it were allowed, it would be ambiguos for an option separated from a value by a white space character
// since we wouldn't know whether that would set the default value or assign it to the following value.
if (mDefaultValue != null && !mRequireExplicitAssignment)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"DefaultValue must not be specified when RequireExplicitAssignment is set to false");
}
// Check that the type of any set default value matches that of this option, or is string, and
// convert it to the type of this option.
if (mDefaultValue != null)
{
if (mDefaultValue.GetType() == typeof(string))
{
try
{
mDefaultValue = GetCheckedValueForSetOperation(mDefaultValue);
}
catch (OverflowException)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"DefaultValue was less than MinValue or greater than MaxValue for this option");
}
catch (FormatException)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"DefaultValue was not specified in the correct format for the type of this option");
}
}
else if (GetBaseType(mOptionType) != mDefaultValue.GetType())
{
try
{
mDefaultValue = Convert.ChangeType(mDefaultValue, GetBaseType(mOptionType), mNumberFormatInfo);
}
catch (InvalidCastException)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"The type of the DefaultValue specified is not compatible with the type of the member to which this attribute applies");
}
}
}
// If this is an enum, check that it doesn't have members only distinguishable by case, and
// add the members to the mEnumerationValues set for speedy access when checking values assigned
// to this member.
Type type = GetBaseType(mOptionType);
if (type.IsEnum)
{
mEnumerationValues = new TreeSet<string>(StringComparer.OrdinalIgnoreCase);
foreach (FieldInfo field in type.GetFields())
{
if (field.IsLiteral)
{
if (mEnumerationValues.Contains(field.Name))
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"This enumeration is not allowed as a command line option since it contains fields that differ only by case");
}
mEnumerationValues.Add(field.Name);
}
}
}
}
private void UpdateNextGroup(int topN, ShardIter <T> shard)
{
while (shard.iter.MoveNext())
{
ISearchGroup <T> group = shard.Next();
MergedGroup <T> mergedGroup = groupsSeen.ContainsKey(group.GroupValue) ? groupsSeen[group.GroupValue] : null;
bool isNew = mergedGroup == null;
//System.out.println(" next group=" + (group.groupValue == null ? "null" : ((BytesRef) group.groupValue).utf8ToString()) + " sort=" + Arrays.toString(group.sortValues));
if (isNew)
{
// Start a new group:
//System.out.println(" new");
mergedGroup = new MergedGroup <T>(group.GroupValue);
mergedGroup.minShardIndex = shard.shardIndex;
Debug.Assert(group.SortValues != null);
mergedGroup.topValues = group.SortValues;
groupsSeen[group.GroupValue] = mergedGroup;
mergedGroup.inQueue = true;
queue.Add(mergedGroup);
}
else if (mergedGroup.processed)
{
// This shard produced a group that we already
// processed; move on to next group...
continue;
}
else
{
//System.out.println(" old");
bool competes = false;
for (int compIDX = 0; compIDX < groupComp.comparators.Length; compIDX++)
{
int cmp = groupComp.reversed[compIDX] * groupComp.comparators[compIDX].CompareValues(group.SortValues[compIDX],
mergedGroup.topValues[compIDX]);
if (cmp < 0)
{
// Definitely competes
competes = true;
break;
}
else if (cmp > 0)
{
// Definitely does not compete
break;
}
else if (compIDX == groupComp.comparators.Length - 1)
{
if (shard.shardIndex < mergedGroup.minShardIndex)
{
competes = true;
}
}
}
//System.out.println(" competes=" + competes);
if (competes)
{
// Group's sort changed -- remove & re-insert
if (mergedGroup.inQueue)
{
queue.Remove(mergedGroup);
}
mergedGroup.topValues = group.SortValues;
mergedGroup.minShardIndex = shard.shardIndex;
queue.Add(mergedGroup);
mergedGroup.inQueue = true;
}
}
mergedGroup.shards.Add(shard);
break;
}
// Prune un-competitive groups:
while (queue.Count > topN)
{
MergedGroup <T> group = queue.Last();
queue.Remove(group);
//System.out.println("PRUNE: " + group);
group.inQueue = false;
}
}
private void CmdAdd_Click(object sender, EventArgs e)
{
mExcludedDates.Add(ExcludeDay.Value.Date);
DaysExcluded.DataSource = mExcludedDates.ToList();
FireCalendarChanged(sender, e);
}
public virtual bool GradientCheck(int numOfChecks, int numOfRandomChecks, double[] x)
{
double epsilon = 1e-5;
double diffThreshold = 0.01;
double diffPctThreshold = 0.1;
double twoEpsilon = epsilon * 2;
int xLen = x.Length;
// log.info("\n\n\ncalling derivativeAt");
DerivativeAt(x);
double[] savedDeriv = new double[xLen];
System.Array.Copy(derivative, 0, savedDeriv, 0, derivative.Length);
int interval = Math.Max(1, x.Length / numOfChecks);
ICollection <int> indicesToCheck = new TreeSet <int>();
for (int paramIndex = 0; paramIndex < xLen; paramIndex += interval)
{
indicesToCheck.Add(paramIndex);
}
for (int i = xLen - 1; i >= 0 && i > xLen - numOfChecks; i--)
{
indicesToCheck.Add(i);
}
for (int i_1 = 1; i_1 < xLen && i_1 < numOfChecks; i_1++)
{
indicesToCheck.Add(i_1);
}
for (int i_2 = 0; i_2 < numOfRandomChecks; i_2++)
{
indicesToCheck.Add(generator.NextInt(xLen));
}
bool returnVal = true;
IList <int> badIndices = new List <int>();
foreach (int paramIndex_1 in indicesToCheck)
{
double oldX = x[paramIndex_1];
x[paramIndex_1] = oldX + epsilon;
// log.info("\n\n\ncalling valueAt1");
double plusVal = ValueAt(x);
x[paramIndex_1] = oldX - epsilon;
// log.info("\n\n\ncalling valueAt2");
double minusVal = ValueAt(x);
double appDeriv = (plusVal - minusVal) / twoEpsilon;
double calcDeriv = savedDeriv[paramIndex_1];
double diff = Math.Abs(appDeriv - calcDeriv);
double pct = diff / Math.Min(Math.Abs(appDeriv), Math.Abs(calcDeriv));
if (diff > diffThreshold && pct > diffPctThreshold)
{
System.Console.Error.Printf("Grad fail at %2d, appGrad=%9.7f, calcGrad=%9.7f, diff=%9.7f, pct=%9.7f\n", paramIndex_1, appDeriv, calcDeriv, diff, pct);
badIndices.Add(paramIndex_1);
returnVal = false;
}
else
{
System.Console.Error.Printf("Grad good at %2d, appGrad=%9.7f, calcGrad=%9.7f, diff=%9.7f, pct=%9.7f\n", paramIndex_1, appDeriv, calcDeriv, diff, pct);
}
x[paramIndex_1] = oldX;
}
if (returnVal)
{
System.Console.Error.Printf("ALL gradients passed. Yay!\n");
}
else
{
log.Info("Bad indices: ");
for (int i_3 = 0; i_3 < badIndices.Count && i_3 < 10; ++i_3)
{
log.Info(" " + badIndices[i_3]);
}
if (badIndices.Count >= 10)
{
log.Info(" (...)");
}
log.Info();
}
return(returnVal);
}
/// <summary>
/// Add the given Date to the list of excluded days. Only the month, day and
/// year of the returned dates are significant.
/// </summary>
public virtual void AddExcludedDate(DateTime excludedDateUtc)
{
DateTime date = excludedDateUtc.Date;
dates.Add(date);
}
private static void CollapsePrepAndPoss(List<TypedDependency> list)
{
// Man oh man, how gnarly is the logic of this method....
var newTypedDeps = new List<TypedDependency>();
// Construct a map from tree nodes to the set of typed
// dependencies in which the node appears as governor.
// cdm: could use CollectionValuedMap here!
var map = new Dictionary<IndexedWord, Util.SortedSet<TypedDependency>>();
var vmod = new List<IndexedWord>();
foreach (TypedDependency typedDep in list)
{
if (!map.ContainsKey(typedDep.Gov))
{
map.Add(typedDep.Gov, new TreeSet<TypedDependency>());
}
map[typedDep.Gov].Add(typedDep);
if (typedDep.Reln == EnglishGrammaticalRelations.VerbalModifier)
{
// look for aux deps which indicate this was a to-be verb
bool foundAux = false;
foreach (TypedDependency auxDep in list)
{
if (auxDep.Reln != EnglishGrammaticalRelations.AuxModifier)
{
continue;
}
if (!auxDep.Gov.Equals(typedDep.Dep) ||
!auxDep.Dep.Value().Equals("to", StringComparison.InvariantCultureIgnoreCase))
{
continue;
}
foundAux = true;
break;
}
if (!foundAux)
{
vmod.Add(typedDep.Dep);
}
}
}
// Do preposition conjunction interaction for
// governor p NP and p NP case ... a lot of special code cdm jan 2006
foreach (TypedDependency td1 in list)
{
if (td1.Reln != EnglishGrammaticalRelations.PrepositionalModifier)
{
continue;
}
if (td1.Reln == GrammaticalRelation.Kill)
{
continue;
}
IndexedWord td1Dep = td1.Dep;
Util.SortedSet<TypedDependency> possibles = map[td1Dep];
if (possibles == null)
{
continue;
}
// look for the "second half"
// unique: the head prep and whether it should be pobj
Tuple<TypedDependency, bool> prepDep = null;
TypedDependency ccDep = null; // treat as unique
// list of dep and prepOtherDep and pobj (or pcomp)
var conjs = new List<Tuple<TypedDependency, TypedDependency, bool>>();
Set<TypedDependency> otherDtrs = new TreeSet<TypedDependency>();
// first look for a conj(prep, prep) (there might be several conj relations!!!)
bool samePrepositionInEachConjunct = true;
int conjIndex = -1;
foreach (TypedDependency td2 in possibles)
{
if (td2.Reln == EnglishGrammaticalRelations.Conjunct)
{
IndexedWord td2Dep = td2.Dep;
string td2DepPOS = td2Dep.Tag();
if (td2DepPOS == PartsOfSpeech.PrepositionOrSubordinateConjunction
|| td2DepPOS == PartsOfSpeech.To)
{
samePrepositionInEachConjunct = samePrepositionInEachConjunct &&
td2Dep.Value().Equals(td1Dep.Value());
Set<TypedDependency> possibles2 = map[td2Dep];
bool pobj = true; // default of collapsing preposition is prep_
TypedDependency prepOtherDep = null;
if (possibles2 != null)
{
foreach (TypedDependency td3 in possibles2)
{
IndexedWord td3Dep = td3.Dep;
string td3DepPOS = td3Dep.Tag();
// CDM Mar 2006: I put in disjunction here when I added in
// PREPOSITIONAL_OBJECT. If it catches all cases, we should
// be able to delete the DEPENDENT disjunct
// maybe better to delete the DEPENDENT disjunct - it creates
// problem with multiple prep (mcdm)
if ((td3.Reln == EnglishGrammaticalRelations.PrepositionalObject ||
td3.Reln == EnglishGrammaticalRelations.PrepositionalComplement) &&
(!(td3DepPOS == PartsOfSpeech.PrepositionOrSubordinateConjunction || td3DepPOS == PartsOfSpeech.To)) && prepOtherDep == null)
{
prepOtherDep = td3;
if (td3.Reln == EnglishGrammaticalRelations.PrepositionalComplement)
{
pobj = false;
}
}
else
{
otherDtrs.Add(td3);
}
}
}
if (conjIndex < td2Dep.Index())
{
conjIndex = td2Dep.Index();
}
conjs.Add(new Tuple<TypedDependency, TypedDependency, Boolean>(td2, prepOtherDep, pobj));
}
}
} // end td2:possibles
if (!conjs.Any())
{
continue;
}
// if we have a conj under a preposition dependency, we look for the other
// parts
string td1DepPOS = td1Dep.Tag();
foreach (TypedDependency td2 in possibles)
{
// we look for the cc linked to this conjDep
// the cc dep must have an index smaller than the dep of conjDep
if (td2.Reln == EnglishGrammaticalRelations.Coordination && td2.Dep.Index() < conjIndex)
{
ccDep = td2;
}
else
{
IndexedWord td2Dep = td2.Dep;
string td2DepPOS = td2Dep.Tag();
if ((td2.Reln == GrammaticalRelation.Dependent ||
td2.Reln == EnglishGrammaticalRelations.PrepositionalObject ||
td2.Reln == EnglishGrammaticalRelations.PrepositionalComplement) &&
(PartsOfSpeech.PrepositionOrSubordinateConjunction == td1DepPOS || PartsOfSpeech.To == td1DepPOS
|| PartsOfSpeech.VerbGerundOrPresentParticiple == td1DepPOS)
&& prepDep == null
&& (!(PartsOfSpeech.Adverb == td2DepPOS || PartsOfSpeech.PrepositionOrSubordinateConjunction == td2DepPOS || PartsOfSpeech.To == td2DepPOS)))
{
// same index trick, in case we have multiple deps
// I deleted this to see if it helped [cdm Jan 2010] &&
// td2.dep().index() < index)
prepDep = new Tuple<TypedDependency, Boolean>(td2,
td2.Reln != EnglishGrammaticalRelations.PrepositionalComplement);
}
else if (!inConjDeps(td2, conjs))
{
// don't want to add the conjDep
// again!
otherDtrs.Add(td2);
}
}
}
if (prepDep == null || ccDep == null)
{
continue; // we can't deal with it in the hairy prep/conj interaction
// case!
}
// check if we have the same prepositions in the conjunction
if (samePrepositionInEachConjunct)
{
// conjDep != null && prepOtherDep !=
// null &&
// OK, we have a conjunction over parallel PPs: Fred flew to Greece and
// to Serbia.
GrammaticalRelation reln = DeterminePrepRelation(map, vmod, td1, td1, prepDep.Item2);
var tdNew = new TypedDependency(reln, td1.Gov, prepDep.Item1.Dep);
newTypedDeps.Add(tdNew);
td1.Reln = GrammaticalRelation.Kill; // remember these are "used up"
prepDep.Item1.Reln = GrammaticalRelation.Kill;
ccDep.Reln = GrammaticalRelation.Kill;
foreach (Tuple<TypedDependency, TypedDependency, Boolean> trip in conjs)
{
TypedDependency conjDep = trip.Item1;
TypedDependency prepOtherDep = trip.Item2;
if (prepOtherDep == null)
{
// CDM July 2010: I think this should only ever happen if there is a
// misparse, but it has happened in such circumstances. You have
// something like (PP in or in (NP Serbia)), with the two
// prepositions the same. We just clean up the mess.
ccDep.Reln = GrammaticalRelation.Kill;
}
else
{
var tdNew2 = new TypedDependency(ConjValue(ccDep.Dep.Value()),
prepDep.Item1.Dep, prepOtherDep.Dep);
newTypedDeps.Add(tdNew2);
prepOtherDep.Reln = GrammaticalRelation.Kill;
}
conjDep.Reln = GrammaticalRelation.Kill;
}
// promote dtrs that would be orphaned
foreach (TypedDependency otd in otherDtrs)
{
otd.Gov = td1.Gov;
}
// Now we need to see if there are any TDs that will be "orphaned"
// by this collapse. Example: if we have:
// dep(drew, on)
// dep(on, book)
// dep(on, right)
// the first two will be collapsed to on(drew, book), but then
// the third one will be orphaned, since its governor no
// longer appears. So, change its governor to 'drew'.
// CDM Feb 2010: This used to not move COORDINATION OR CONJUNCT, but now
// it does, since they're not automatically deleted
// Some things in possibles may have already been changed, so check gov
foreach (TypedDependency td2 in possibles)
{
if (td2.Reln != GrammaticalRelation.Kill && td2.Gov.Equals(td1.Dep))
{
// && td2.reln()
// != COORDINATION
// && td2.reln()
// != CONJUNCT
td2.Gov = td1.Gov;
}
}
continue; // This one has been dealt with successfully
} // end same prepositions
// case of "Lufthansa flies to and from Serbia". Make it look like next
// case :-)
// that is, the prepOtherDep should be the same as prepDep !
var newConjList = new List<Tuple<TypedDependency, TypedDependency, bool>>();
foreach (Tuple<TypedDependency, TypedDependency, Boolean> trip in conjs)
{
if (trip.Item1 != null && trip.Item2 == null)
{
/*trip.Item2 = new TypedDependency(prepDep.Item1.reln(), trip.Item1.dep(), prepDep.Item1.dep());
trip.Item3 = prepDep.Item2;*/
newConjList.Add(new Tuple<TypedDependency, TypedDependency, bool>(trip.Item1,
new TypedDependency(prepDep.Item1.Reln, trip.Item1.Dep, prepDep.Item1.Dep),
prepDep.Item2));
}
else
{
newConjList.Add(trip);
}
}
conjs = newConjList;
// we have two different prepositions in the conjunction
// in this case we need to add a node
// "Bill jumped over the fence and through the hoop"
// prep_over(jumped, fence)
// conj_and(jumped, jumped)
// prep_through(jumped, hoop)
GrammaticalRelation _reln = DeterminePrepRelation(map, vmod, td1, td1, prepDep.Item2);
var _tdNew = new TypedDependency(_reln, td1.Gov, prepDep.Item1.Dep);
newTypedDeps.Add(_tdNew);
td1.Reln = GrammaticalRelation.Kill; // remember these are "used up"
prepDep.Item1.Reln = GrammaticalRelation.Kill;
ccDep.Reln = GrammaticalRelation.Kill;
// so far we added the first prep grammatical relation
int copyNumber = 1;
foreach (Tuple<TypedDependency, TypedDependency, bool> trip in conjs)
{
TypedDependency conjDep = trip.Item1;
TypedDependency prepOtherDep = trip.Item2;
bool pobj = trip.Item3;
// OK, we have a conjunction over different PPs
// we create a new node;
// in order to make a distinction between the original node and its copy
// we add a "copy" entry in the CoreLabel
// existence of copy key is checked at printing (ToString method of
// TypedDependency)
IndexedWord label = td1.Gov.MakeCopy(copyNumber);
copyNumber++;
// now we add the conjunction relation between td1.gov and the copy
// the copy has the same label as td1.gov() but is another TreeGraphNode
var tdNew2 = new TypedDependency(ConjValue(ccDep.Dep.Value()), td1.Gov, label);
newTypedDeps.Add(tdNew2);
// now we still need to add the second prep grammatical relation
// between the copy and the dependent of the prepOtherDep node
GrammaticalRelation reln2 = DeterminePrepRelation(map, vmod, conjDep, td1, pobj);
var tdNew3 = new TypedDependency(reln2, label, prepOtherDep.Dep);
newTypedDeps.Add(tdNew3);
conjDep.Reln = GrammaticalRelation.Kill;
prepOtherDep.Reln = GrammaticalRelation.Kill;
// promote dtrs that would be orphaned
foreach (TypedDependency otd in otherDtrs)
{
// special treatment for prepositions: the original relation is
// likely to be a "dep" and we want this to be a "prep"
if (otd.Dep.Tag() == PartsOfSpeech.PrepositionOrSubordinateConjunction)
{
otd.Reln = EnglishGrammaticalRelations.PrepositionalModifier;
}
otd.Gov = td1.Gov;
}
}
// Now we need to see if there are any TDs that will be "orphaned" off
// the first preposition
// by this collapse. Example: if we have:
// dep(drew, on)
// dep(on, book)
// dep(on, right)
// the first two will be collapsed to on(drew, book), but then
// the third one will be orphaned, since its governor no
// longer appears. So, change its governor to 'drew'.
// CDM Feb 2010: This used to not move COORDINATION OR CONJUNCT, but now
// it does, since they're not automatically deleted
foreach (TypedDependency td2 in possibles)
{
if (td2.Reln != GrammaticalRelation.Kill)
{
// && td2.reln() != COORDINATION &&
// td2.reln() != CONJUNCT) {
td2.Gov = td1.Gov;
}
}
// end for different prepositions
} // for TypedDependency td1 : list
// below here is the single preposition/possessor basic case!!
foreach (TypedDependency td1 in list)
{
if (td1.Reln == GrammaticalRelation.Kill)
{
continue;
}
IndexedWord td1Dep = td1.Dep;
string td1DepPOS = td1Dep.Tag();
// find all other typedDeps having our dep as gov
Set<TypedDependency> possibles = map[td1Dep];
if (possibles != null &&
(td1.Reln == EnglishGrammaticalRelations.PrepositionalModifier ||
td1.Reln == EnglishGrammaticalRelations.PossessionModifier ||
td1.Reln == EnglishGrammaticalRelations.Conjunct))
{
// look for the "second half"
bool pobj = true; // default for prep relation is prep_
foreach (TypedDependency td2 in possibles)
{
if (td2.Reln != EnglishGrammaticalRelations.Coordination &&
td2.Reln != EnglishGrammaticalRelations.Conjunct)
{
IndexedWord td2Dep = td2.Dep;
string td2DepPOS = td2Dep.Tag();
if ((td1.Reln == EnglishGrammaticalRelations.PossessionModifier ||
td1.Reln == EnglishGrammaticalRelations.Conjunct))
{
if (td2.Reln == EnglishGrammaticalRelations.PossessiveModifier)
{
if (! map.ContainsKey(td2Dep))
{
// if 's has no kids of its own (it shouldn't!)
td2.Reln = GrammaticalRelation.Kill;
}
}
}
else if ((td2.Reln == EnglishGrammaticalRelations.PrepositionalObject ||
td2.Reln == EnglishGrammaticalRelations.PrepositionalComplement) &&
(PartsOfSpeech.PrepositionOrSubordinateConjunction == td1DepPOS
|| PartsOfSpeech.To == td1DepPOS || PartsOfSpeech.VerbGerundOrPresentParticiple == td1DepPOS) &&
(!(PartsOfSpeech.Adverb == td2DepPOS
|| PartsOfSpeech.PrepositionOrSubordinateConjunction == td2DepPOS || PartsOfSpeech.To == td2DepPOS)) &&
!IsConjWithNoPrep(td2.Gov, possibles))
{
// we don't collapse preposition conjoined with a non-preposition
// to avoid disconnected constituents
// OK, we have a pair td1, td2 to collapse to td3
// check whether we are in a pcomp case:
if (td2.Reln == EnglishGrammaticalRelations.PrepositionalComplement)
{
pobj = false;
}
GrammaticalRelation reln = DeterminePrepRelation(map, vmod, td1, td1, pobj);
var td3 = new TypedDependency(reln, td1.Gov, td2.Dep);
// add it to map to deal with recursive cases like "achieved this (PP (PP in part) with talent)"
map[td3.Gov].Add(td3);
newTypedDeps.Add(td3);
td1.Reln = GrammaticalRelation.Kill; // remember these are "used up"
td2.Reln = GrammaticalRelation.Kill; // remember these are "used up"
}
}
} // for TypedDependency td2
}
// Now we need to see if there are any TDs that will be "orphaned"
// by this collapse. Example: if we have:
// dep(drew, on)
// dep(on, book)
// dep(on, right)
// the first two will be collapsed to on(drew, book), but then
// the third one will be orphaned, since its governor no
// longer appears. So, change its governor to 'drew'.
// CDM Feb 2010: This used to not move COORDINATION OR CONJUNCT, but now
// it does, since they're not automatically deleted
if (possibles != null && td1.Reln == GrammaticalRelation.Kill)
{
foreach (TypedDependency td2 in possibles)
{
if (td2.Reln != GrammaticalRelation.Kill)
{
// && td2.reln() != COORDINATION &&
// td2.reln() != CONJUNCT) {
td2.Gov = td1.Gov;
}
}
}
} // for TypedDependency td1
// now remove typed dependencies with reln "kill" and add new ones.
/*for (Iterator<TypedDependency> iter = list.iterator(); iter.hasNext();) {
TypedDependency td = iter.next();
if (td.reln() == KILL) {
iter.remove();
}
}*/
list.RemoveAll(td => td.Reln == GrammaticalRelation.Kill);
list.AddRange(newTypedDeps);
} // end collapsePrepAndPoss()
/// <summary>
/// Initializes a new instance of the <see cref="Option"/> class.
/// </summary>
/// <param name="attribute">The attribute describing this option.</param>
/// <param name="memberInfo">The <see cref="MemberInfo"/> object pointing to the member to which the attribute was applied.</param>
/// <param name="cmdLineObject">The command line manager object.</param>
/// <param name="optionGroups">A complete list of all available option groups.</param>
/// <param name="numberFormatInfo">The number format info to use for parsing numerical arguments.</param>
public Option(CommandLineOptionAttribute attribute, MemberInfo memberInfo, object cmdLineObject,
ICollection <OptionGroup> optionGroups, NumberFormatInfo numberFormatInfo)
{
mObject = cmdLineObject;
mMember = memberInfo;
mUsage = attribute.BoolFunction;
mDescription = attribute.Description;
mNumberFormatInfo = numberFormatInfo ?? CultureInfo.CurrentCulture.NumberFormat;
mDefaultValue = attribute.DefaultAssignmentValue;
mMinValue = attribute.MinValue;
mMaxValue = attribute.MaxValue;
// Check the validity of the member for which this attribute was defined
switch (memberInfo.MemberType)
{
case MemberTypes.Field:
FieldInfo fieldInfo = (FieldInfo)memberInfo;
if (fieldInfo.IsInitOnly || fieldInfo.IsLiteral)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal field for this attribute; field must be writeable");
}
mOptionType = fieldInfo.FieldType;
break;
case MemberTypes.Method:
MethodInfo method = (MethodInfo)memberInfo;
ParameterInfo[] parameters = method.GetParameters();
if (parameters.Length != 1)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal method for this attribute; the method must accept exactly one parameter");
}
if (parameters[0].IsOut)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal method for this attribute; the parameter of the method must not be an out parameter");
}
if (IsArray(parameters[0].ParameterType) || IsCollectionType(parameters[0].ParameterType))
{
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal method for this attribute; the parameter of the method must be a non-array and non-collection type");
}
mOptionType = parameters[0].ParameterType;
break;
case MemberTypes.Property:
PropertyInfo propInfo = (PropertyInfo)memberInfo;
if (!propInfo.CanWrite && !IsCollectionType(propInfo.PropertyType))
{
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal property for this attribute; property for non-collection type must be writable");
}
if (!propInfo.CanRead && IsCollectionType(propInfo.PropertyType))
{
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal property for this attribute; property for collection type must be readable");
}
if (!(propInfo.CanRead && propInfo.CanWrite) && IsArray(propInfo.PropertyType))
{
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal property for this attribute; property representing array type must be both readable and writeable");
}
mOptionType = propInfo.PropertyType;
break;
default:
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Illegal member for this attribute; member must be a property, method (accepting one parameter) or a field");
}
mMinOccurs = attribute.MinOccurs;
// MaxOccurs does not have a default value (since this is different for various types), so we set it here.
if (!attribute.IsMaxOccursSet)
{
// Use default setting for MaxOccurs
if (IsArray(mOptionType) || IsCollectionType(mOptionType))
{
mMaxOccurs = 0; // Unlimited
}
else
{
mMaxOccurs = 1;
}
}
else
{
mMaxOccurs = attribute.MaxOccurs;
}
if (mMinOccurs > mMaxOccurs && mMaxOccurs > 0)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
String.Format(CultureInfo.CurrentUICulture, "MinOccurs ({0}) must not be larger than MaxOccurs ({1})", mMinOccurs, mMaxOccurs));
}
if (mMaxOccurs != 1 && !(IsArray(mOptionType) || IsCollectionType(mOptionType)) && mMember.MemberType != MemberTypes.Method)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), memberInfo,
"Invalid cardinality for member; MaxOccurs must be equal to one (1) for any non-array or non-collection type");
}
CommandLineManagerAttribute objectAttr = (CommandLineManagerAttribute)Attribute.GetCustomAttribute(mObject.GetType(), typeof(CommandLineManagerAttribute));
if (objectAttr == null)
{
throw new AttributeException(String.Format(CultureInfo.CurrentUICulture,
"Class {0} contains a CommandLineOptionAttribute, but does not have the attribute CommandLineObjectAttribute", mObject.GetType().FullName));
}
// Assign the name of this option from the member itself if no name is explicitly provided
if (attribute.Name == null)
{
mName = memberInfo.Name;
}
else
{
mName = attribute.Name;
}
// Find the group (if any) that this option belongs to in the list of available option groups
if (attribute.GroupId != null)
{
if (!optionGroups.Find(new Func <OptionGroup, bool>(
delegate(OptionGroup searchGroup)
{
return(attribute.GroupId.Equals(searchGroup.Id));
}), out mGroup))
{
throw new LogicException(String.Format(CultureInfo.CurrentUICulture, "Undefined group {0} referenced from member {1} in {2}", attribute.GroupId, memberInfo.Name, cmdLineObject.GetType().FullName));
}
mGroup.Options.Add(mName, this);
}
// Recursively find out if this option requires explicit assignment
if (attribute.DoesRequireExplicitAssignment.HasValue)
{
mRequireExplicitAssignment = attribute.DoesRequireExplicitAssignment.Value;
}
else if (mGroup != null)
{
mRequireExplicitAssignment = mGroup.RequireExplicitAssignment;
}
else
{
mRequireExplicitAssignment = objectAttr.RequireExplicitAssignment;
}
// Make sure the type of the field, property or method is supported
if (!IsTypeSupported(mOptionType))
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"Unsupported type for command line option.");
}
// Make sure MinValue and MaxValue is not specified for any non-numerical type.
if (mMinValue != null || mMaxValue != null)
{
if (!IsNumericalType)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"MinValue and MaxValue must not be specified for a non-numerical type");
}
else if (!mMinValue.GetType().IsAssignableFrom(GetBaseType(mOptionType)))
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"Illegal value for MinValue or MaxValue, not the same type as option");
}
}
// Some special checks for numerical types
if (IsNumericalType)
{
// Assign the default MinValue if it was not set and this is a numerical type
if (IsNumericalType && mMinValue == null)
{
mMinValue = GetBaseType(mOptionType).GetField("MinValue", BindingFlags.Static | BindingFlags.Public).GetValue(null);
}
// Assign the defaul MaxValue if it was not set and this is a numerical type
if (IsNumericalType && mMaxValue == null)
{
mMaxValue = GetBaseType(mOptionType).GetField("MaxValue", BindingFlags.Static | BindingFlags.Public).GetValue(null);
}
// Check that MinValue <= MaxValue
if (IsNumericalType && ((IComparable)MinValue).CompareTo(MaxValue) > 0)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"MinValue must not be greater than MaxValue");
}
}
// Check that the DefaultValue is not set if the option does not require explicit assignment.
// If it were allowed, it would be ambiguos for an option separated from a value by a white space character
// since we wouldn't know whether that would set the default value or assign it to the following value.
if (mDefaultValue != null && !mRequireExplicitAssignment)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"DefaultValue must not be specified when RequireExplicitAssignment is set to false");
}
// Check that the type of any set default value matches that of this option, or is string, and
// convert it to the type of this option.
if (mDefaultValue != null)
{
if (mDefaultValue.GetType() == typeof(string))
{
try
{
mDefaultValue = GetCheckedValueForSetOperation(mDefaultValue);
}
catch (OverflowException)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"DefaultValue was less than MinValue or greater than MaxValue for this option");
}
catch (FormatException)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"DefaultValue was not specified in the correct format for the type of this option");
}
}
else if (GetBaseType(mOptionType) != mDefaultValue.GetType())
{
try
{
mDefaultValue = Convert.ChangeType(mDefaultValue, GetBaseType(mOptionType), mNumberFormatInfo);
}
catch (InvalidCastException)
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"The type of the DefaultValue specified is not compatible with the type of the member to which this attribute applies");
}
}
}
// If this is an enum, check that it doesn't have members only distinguishable by case, and
// add the members to the mEnumerationValues set for speedy access when checking values assigned
// to this member.
Type type = GetBaseType(mOptionType);
if (type.IsEnum)
{
mEnumerationValues = new TreeSet <string>(StringComparer.OrdinalIgnoreCase);
foreach (FieldInfo field in type.GetFields())
{
if (field.IsLiteral)
{
if (mEnumerationValues.Contains(field.Name))
{
throw new AttributeException(typeof(CommandLineOptionAttribute), mMember,
"This enumeration is not allowed as a command line option since it contains fields that differ only by case");
}
mEnumerationValues.Add(field.Name);
}
}
}
}
/**
* Copies a sheet from a read-only version to the writable version.
* Performs shallow copies
*/
public void copySheet()
{
shallowCopyCells();
// Copy the column info records
CSharpJExcel.Jxl.Read.Biff.ColumnInfoRecord[] readCirs = fromSheet.getColumnInfos();
for (int i = 0; i < readCirs.Length; i++)
{
CSharpJExcel.Jxl.Read.Biff.ColumnInfoRecord rcir = readCirs[i];
for (int j = rcir.getStartColumn(); j <= rcir.getEndColumn(); j++)
{
ColumnInfoRecord cir = new ColumnInfoRecord(rcir, j,
formatRecords);
cir.setHidden(rcir.getHidden());
columnFormats.Add(cir);
}
}
// Copy the hyperlinks
Hyperlink[] hls = fromSheet.getHyperlinks();
for (int i = 0; i < hls.Length; i++)
{
WritableHyperlink hr = new WritableHyperlink
(hls[i], toSheet);
hyperlinks.Add(hr);
}
// Copy the merged cells
Range[] merged = fromSheet.getMergedCells();
for (int i = 0; i < merged.Length; i++)
{
mergedCells.add(new SheetRangeImpl((SheetRangeImpl)merged[i], toSheet));
}
// Copy the row properties
try
{
CSharpJExcel.Jxl.Read.Biff.RowRecord[] rowprops = fromSheet.getRowProperties();
for (int i = 0; i < rowprops.Length; i++)
{
RowRecord rr = toSheet.getRowRecord(rowprops[i].getRowNumber());
XFRecord format = rowprops[i].hasDefaultFormat() ?
formatRecords.getXFRecord(rowprops[i].getXFIndex()) : null;
rr.setRowDetails(rowprops[i].getRowHeight(),
rowprops[i].matchesDefaultFontHeight(),
rowprops[i].isCollapsed(),
rowprops[i].getOutlineLevel(),
rowprops[i].getGroupStart(),
format);
numRows = System.Math.Max(numRows, rowprops[i].getRowNumber() + 1);
}
}
catch (RowsExceededException e)
{
// Handle the rows exceeded exception - this cannot occur since
// the sheet we are copying from will have a valid number of rows
Assert.verify(false);
}
// Copy the headers and footers
// sheetWriter.setHeader(new HeaderRecord(si.getHeader()));
// sheetWriter.setFooter(new FooterRecord(si.getFooter()));
// Copy the page breaks
int[] rowbreaks = fromSheet.getRowPageBreaks();
if (rowbreaks != null)
{
for (int i = 0; i < rowbreaks.Length; i++)
{
rowBreaks.Add(rowbreaks[i]);
}
}
int[] columnbreaks = fromSheet.getColumnPageBreaks();
if (columnbreaks != null)
{
for (int i = 0; i < columnbreaks.Length; i++)
{
columnBreaks.Add(columnbreaks[i]);
}
}
// Copy the charts
sheetWriter.setCharts(fromSheet.getCharts());
// Copy the drawings
DrawingGroupObject[] dr = fromSheet.getDrawings();
for (int i = 0; i < dr.Length; i++)
{
if (dr[i] is CSharpJExcel.Jxl.Biff.Drawing.Drawing)
{
WritableImage wi = new WritableImage
(dr[i], toSheet.getWorkbook().getDrawingGroup());
drawings.Add(wi);
images.Add(wi);
}
else if (dr[i] is CSharpJExcel.Jxl.Biff.Drawing.Comment)
{
CSharpJExcel.Jxl.Biff.Drawing.Comment c =
new CSharpJExcel.Jxl.Biff.Drawing.Comment(dr[i],
toSheet.getWorkbook().getDrawingGroup(),
workbookSettings);
drawings.Add(c);
// Set up the reference on the cell value
CellValue cv = (CellValue)toSheet.getWritableCell(c.getColumn(),
c.getRow());
Assert.verify(cv.getCellFeatures() != null);
cv.getWritableCellFeatures().setCommentDrawing(c);
}
else if (dr[i] is CSharpJExcel.Jxl.Biff.Drawing.Button)
{
CSharpJExcel.Jxl.Biff.Drawing.Button b =
new CSharpJExcel.Jxl.Biff.Drawing.Button
(dr[i],
toSheet.getWorkbook().getDrawingGroup(),
workbookSettings);
drawings.Add(b);
}
else if (dr[i] is CSharpJExcel.Jxl.Biff.Drawing.ComboBox)
{
CSharpJExcel.Jxl.Biff.Drawing.ComboBox cb =
new CSharpJExcel.Jxl.Biff.Drawing.ComboBox
(dr[i],
toSheet.getWorkbook().getDrawingGroup(),
workbookSettings);
drawings.Add(cb);
}
else if (dr[i] is CSharpJExcel.Jxl.Biff.Drawing.CheckBox)
{
CSharpJExcel.Jxl.Biff.Drawing.CheckBox cb =
new CSharpJExcel.Jxl.Biff.Drawing.CheckBox
(dr[i],
toSheet.getWorkbook().getDrawingGroup(),
workbookSettings);
drawings.Add(cb);
}
}
// Copy the data validations
DataValidation rdv = fromSheet.getDataValidation();
if (rdv != null)
{
dataValidation = new DataValidation(rdv,
toSheet.getWorkbook(),
toSheet.getWorkbook(),
workbookSettings);
uint objid = dataValidation.getComboBoxObjectId();
if (objid != 0)
{
comboBox = (ComboBox)drawings[(int)objid];
}
}
// Copy the conditional formats
ConditionalFormat[] cf = fromSheet.getConditionalFormats();
if (cf.Length > 0)
{
for (int i = 0; i < cf.Length; i++)
{
conditionalFormats.Add(cf[i]);
}
}
// Get the autofilter
autoFilter = fromSheet.getAutoFilter();
// Copy the workspace options
sheetWriter.setWorkspaceOptions(fromSheet.getWorkspaceOptions());
// Set a flag to indicate if it contains a chart only
if (fromSheet.getSheetBof().isChart())
{
chartOnly = true;
sheetWriter.setChartOnly();
}
// Copy the environment specific print record
if (fromSheet.getPLS() != null)
{
if (fromSheet.getWorkbookBof().isBiff7())
{
//logger.warn("Cannot copy Biff7 print settings record - ignoring");
}
else
{
plsRecord = new PLSRecord(fromSheet.getPLS());
}
}
// Copy the button property set
if (fromSheet.getButtonPropertySet() != null)
{
buttonPropertySet = new ButtonPropertySetRecord
(fromSheet.getButtonPropertySet());
}
// Copy the outline levels
maxRowOutlineLevel = fromSheet.getMaxRowOutlineLevel();
maxColumnOutlineLevel = fromSheet.getMaxColumnOutlineLevel();
}
public static bool Add(this TreeSet <TestPriorityQueue.Integer> ss, int value)
{
return(ss.Add(new TestPriorityQueue.Integer(value)));
}
public void Add(Segment s)
{
PositionOrdered.Add(s);
WidthOrdered.Add(s);
}
/**
* @see <a href="http://en.wikipedia.org/wiki/Sweep_line_algorithm">Sweep line algorithm</a>
*/
private void SweepCleanColumns(CT_Cols cols, CT_Col[] flattenedColsArray, CT_Col overrideColumn)
{
List <CT_Col> flattenedCols = new List <CT_Col>(flattenedColsArray);
TreeSet <CT_Col> currentElements = new TreeSet <CT_Col>(CTColComparator.BY_MAX);
IEnumerator <CT_Col> flIter = flattenedCols.GetEnumerator();
CT_Col haveOverrideColumn = null;
long lastMaxIndex = 0;
long currentMax = 0;
IList <CT_Col> toRemove = new List <CT_Col>();
int pos = -1;
//while (flIter.hasNext())
while ((pos + 1) < flattenedCols.Count)
{
//CTCol col = flIter.next();
pos++;
CT_Col col = flattenedCols[pos];
long currentIndex = col.min;
long colMax = col.max;
long nextIndex = (colMax > currentMax) ? colMax : currentMax;
//if (flIter.hasNext()) {
if ((pos + 1) < flattenedCols.Count)
{
//nextIndex = flIter.next().getMin();
nextIndex = flattenedCols[pos + 1].min;
//flIter.previous();
}
IEnumerator <CT_Col> iter = currentElements.GetEnumerator();
toRemove.Clear();
while (iter.MoveNext())
{
CT_Col elem = iter.Current;
if (currentIndex <= elem.max)
{
break; // all passed elements have been purged
}
//iter.remove();
toRemove.Add(elem);
}
foreach (CT_Col rc in toRemove)
{
currentElements.Remove(rc);
}
if (!(currentElements.Count == 0) && lastMaxIndex < currentIndex)
{
// we need to process previous elements first
CT_Col[] copyCols = new CT_Col[currentElements.Count];
currentElements.CopyTo(copyCols);
insertCol(cols, lastMaxIndex, currentIndex - 1, copyCols, true, haveOverrideColumn);
}
currentElements.Add(col);
if (colMax > currentMax)
{
currentMax = colMax;
}
if (col.Equals(overrideColumn))
{
haveOverrideColumn = overrideColumn;
}
while (currentIndex <= nextIndex && !(currentElements.Count == 0))
{
NPOI.Util.Collections.HashSet <CT_Col> currentIndexElements = new NPOI.Util.Collections.HashSet <CT_Col>();
long currentElemIndex;
{
// narrow scope of currentElem
CT_Col currentElem = currentElements.First();
currentElemIndex = currentElem.max;
currentIndexElements.Add(currentElem);
while (true)
{
CT_Col higherElem = currentElements.Higher(currentElem);
if (higherElem == null || higherElem.max != currentElemIndex)
{
break;
}
currentElem = higherElem;
currentIndexElements.Add(currentElem);
if (colMax > currentMax)
{
currentMax = colMax;
}
if (col.Equals(overrideColumn))
{
haveOverrideColumn = overrideColumn;
}
}
}
//if (currentElemIndex < nextIndex || !flIter.hasNext()) {
if (currentElemIndex < nextIndex || !((pos + 1) < flattenedCols.Count))
{
CT_Col[] copyCols = new CT_Col[currentElements.Count];
currentElements.CopyTo(copyCols);
insertCol(cols, currentIndex, currentElemIndex, copyCols, true, haveOverrideColumn);
//if (flIter.hasNext()) {
if ((pos + 1) < flattenedCols.Count)
{
if (nextIndex > currentElemIndex)
{
//currentElements.removeAll(currentIndexElements);
foreach (CT_Col rc in currentIndexElements)
{
currentElements.Remove(rc);
}
if (currentIndexElements.Contains(overrideColumn))
{
haveOverrideColumn = null;
}
}
}
else
{
//currentElements.removeAll(currentIndexElements);
foreach (CT_Col rc in currentIndexElements)
{
currentElements.Remove(rc);
}
if (currentIndexElements.Contains(overrideColumn))
{
haveOverrideColumn = null;
}
}
lastMaxIndex = currentIndex = currentElemIndex + 1;
}
else
{
lastMaxIndex = currentIndex;
currentIndex = nextIndex + 1;
}
}
}
SortColumns(cols);
}
private IEnumerable<BrowseFacet> BuildDynamicRanges()
{
TreeSet<BrowseFacet> facetSet = new TreeSet<BrowseFacet>(new RangeComparator());
int minCount = ospec.MinHitCount;
// we would skip first element at index 0 (which means no value)
for (int i = 1; i < count.Length; ++i)
{
if (count[i] >= minCount)
{
object val = dataCache.valArray.GetRawValue(i);
facetSet.Add(new BrowseFacet(val, count[i]));
}
}
if (ospec.MaxCount <= 0)
{
ospec.MaxCount = 5;
}
int maxCount = ospec.MaxCount;
BrowseFacet[] facets = facetSet.ToArray();
if (facetSet.Count < maxCount)
{
ConvertFacets(facets);
}
else
{
facets = FoldChoices(facets, maxCount);
}
return facets;
}
private async void LoadData()
{
if (projectId != 0)
{
if (Utility.IsInternetAvailable(Application.Context))
{
try
{
reportService = new ReportService(userSession.AccessToken);
var unOrderedReportList = await reportService.GetArchivedReportList(projectId);
var listBeforFilter = unOrderedReportList.Where(x => x.IsArchived).OrderByDescending(a => a.CreatedDateTime.Date).ThenByDescending(a => a.CreatedDateTime.TimeOfDay);
var resultList = listBeforFilter.ToList();
emptyView.Visibility = resultList.Count == 0 ? ViewStates.Visible : ViewStates.Gone;
headerandItemsList = new List <Report>();
TreeSet sectionHeaders = new TreeSet();
var todayheader = false;
var yesterday = false;
var lastweek = false;
var other = false;
for (int i = 0; i < resultList.Count; i++)
{
if (resultList[i].CreatedDateTime.Date >= DateTime.Today)
{
if (todayheader == false)
{
todayheader = true;
Report reportDataDataDto = new Report();
reportDataDataDto.ReportName = Application.Context.Resources.GetString(Resource.String.today);
headerandItemsList.Add(reportDataDataDto);
sectionHeaders.Add(headerandItemsList.Count - 1);
}
headerandItemsList.Add(resultList[i]);
}
else if (resultList[i].CreatedDateTime.Date == DateTime.Today.AddDays(-1))
{
if (!yesterday)
{
yesterday = true;
Report reportDataDataDto = new Report();
reportDataDataDto.ReportName = Application.Context.Resources.GetString(Resource.String.yesterday);
headerandItemsList.Add(reportDataDataDto);
sectionHeaders.Add(headerandItemsList.Count - 1);
}
headerandItemsList.Add(resultList[i]);
}
else if (resultList[i].CreatedDateTime.Date <DateTime.Today.AddDays(-2) && resultList[i].CreatedDateTime.Date> DateTime.Today.AddDays(-7))
{
if (!lastweek)
{
lastweek = true;
Report reportDataDataDto = new Report();
reportDataDataDto.ReportName = Application.Context.Resources.GetString(Resource.String.last_week);
headerandItemsList.Add(reportDataDataDto);
sectionHeaders.Add(headerandItemsList.Count - 1);
}
headerandItemsList.Add(resultList[i]);
}
else
{
if (!other)
{
other = true;
Report reportDataDataDto = new Report();
reportDataDataDto.ReportName = Application.Context.Resources.GetString(Resource.String.other);
headerandItemsList.Add(reportDataDataDto);
sectionHeaders.Add(headerandItemsList.Count - 1);
}
headerandItemsList.Add(resultList[i]);
}
}
listAdapter = new ReportListArchiveAdapter(Application.Context, headerandItemsList, sectionHeaders);
ListView.Adapter = listAdapter;
listAdapter.NotifyDataSetChanged();
}
catch (Exception)
{
Log.Debug("Exception", "Archeive List");
}
}
}
else
{
emptyView.Visibility = ViewStates.Visible;
}
}