/// <summary>
/// Initializes a new instance of the EnumerableProxy class.
/// </summary>
/// <param name="wrapperScope">The wrapper scope.</param>
/// <param name="underlyingImplementation">The underlying implementation of the proxy.</param>
public EnumerableProxy(IWrapperScope wrapperScope, System.Collections.IEnumerable underlyingImplementation)
{
ExceptionUtilities.CheckArgumentNotNull(wrapperScope, "wrapperScope");
ExceptionUtilities.CheckArgumentNotNull(underlyingImplementation, "underlyingImplementation");
this.Scope = wrapperScope;
this.underlyingImplementation = underlyingImplementation;
}
/// <summary>
/// Create a graph on the server of a data series
/// </summary>
/// <param name="dataSetX">IEnumerable horizontal series</param>
/// <param name="dataSetY">IEnumberable vertical series</param>
public Grapher(System.Collections.IEnumerable dataSetX, System.Collections.IEnumerable dataSetY)
{
this.dataSetX = dataSetX;
this.dataSetY = dataSetY;
if (!File.Exists(System.Web.Hosting.HostingEnvironment.MapPath(filePath)))
{
//TODO log any exceptions
chart = new Chart(width: 600, height: 600);
chart.AddSeries(chartType: "Line",
xValue: dataSetX,
yValues: dataSetY);
chart.Save(filePathName, "png");
//TODO solve file cleanup problem
}
}
/// <summary>
/// Assert that an array, list or other collection is ordered
/// </summary>
/// <param name="collection">An array, list or other collection implementing System.Collections.IEnumerable</param>
/// <param name="comparer">A custom comparer to perform the comparisons</param>
public static void IsOrdered(System.Collections.IEnumerable collection, System.Collections.IComparer comparer)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.IsOrdered(collection, comparer));
}
/// <summary>
/// Assert that an array,list or other collection is empty
/// </summary>
/// <param name="collection">An array, list or other collection implementing System.Collections.IEnumerable</param>
public static void IsNotEmpty(System.Collections.IEnumerable collection)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.IsNotEmpty(collection));
}
/// <summary>
/// Asserts that all items contained in collection are not equal to null.
/// </summary>
/// <param name="collection">System.Collections.IEnumerable containing objects to be considered</param>
public static void AllItemsAreNotNull(System.Collections.IEnumerable collection)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.AllItemsAreNotNull(collection));
}
/// <summary>
/// Asserts that the subset contains the superset.
/// </summary>
/// <param name="superset">The System.Collections.IEnumerable superset to be considered</param>
/// <param name="subset">The System.Collections.IEnumerable subset to be considered</param>
public static void IsSupersetOf(System.Collections.IEnumerable superset, System.Collections.IEnumerable subset)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.IsSupersetOf(superset, subset));
}
/// <summary>
/// Enumerator constructor
/// </summary>
public AffixEntryEnumerator(AffixEntryCollection mappings)
{
this.Local = ((System.Collections.IEnumerable)(mappings));
this.Base = Local.GetEnumerator();
}
/// <summary>
/// Enumerator constructor
/// </summary>
public RecentFileEnumerator(RecentFileCollection recMappings)
{
this.iEnLocal = ((System.Collections.IEnumerable)(recMappings));
this.iEnBase = iEnLocal.GetEnumerator();
}
public void Dispose()
{
_enumerable = null;
_hasNext = false;
_iterator = null;
}
public void Single(System.Collections.IEnumerable collection, object expected)
{
Assert.Single(collection, expected);
}
public void Single(System.Collections.IEnumerable collection)
{
Assert.Single(collection);
}
public void NotEmpty(System.Collections.IEnumerable collection)
{
Assert.NotEmpty(collection);
}
/// <summary>
/// Indica se a sequência é não nula e possui itens.
/// </summary>
/// <param name="instance"></param>
/// <returns></returns>
public static bool HasItems(this System.Collections.IEnumerable instance)
{
return((instance != null) && instance.GetEnumerator().MoveNext());
}
/// <summary>
/// Verifica se a sequência é nula ou está vazia.
/// </summary>
/// <param name="instance"></param>
/// <returns></returns>
public static bool IsNullOrEmpty(this System.Collections.IEnumerable instance)
{
return((instance == null) || (!instance.GetEnumerator().MoveNext()));
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="enumerable"></param>
public Enumerable(System.Collections.IEnumerable enumerable)
{
_enumerable = enumerable;
}
/// <summary>
/// Enumerator constructor
/// </summary>
public PhoneticRuleEnumerator(PhoneticRuleCollection mappings)
{
this.Local = ((System.Collections.IEnumerable)(mappings));
this.Base = Local.GetEnumerator();
}
public override object CreateOutput(System.Collections.IEnumerable context)
{
throw new InvalidOperationException();
}
/// <summary>
/// Enumerator constructor
/// </summary>
public FormSettingsEnumerator(FormSettingsCollection forMappings)
{
this.iEnLocal = ((System.Collections.IEnumerable)(forMappings));
this.iEnBase = iEnLocal.GetEnumerator();
}
protected static string GetComparisonStatement(StandardProviderParameters std, esDynamicQuerySerializable query, List <esComparison> items, string prefix)
{
string sql = String.Empty;
string comma = String.Empty;
bool first = true;
IDynamicQuerySerializableInternal iQuery = query as IDynamicQuerySerializableInternal;
//=======================================
// WHERE
//=======================================
if (items != null)
{
sql += prefix;
string compareTo = String.Empty;
foreach (esComparison comparisonItem in items)
{
esComparison.esComparisonData comparisonData = (esComparison.esComparisonData)comparisonItem;
esDynamicQuerySerializable subQuery = null;
bool requiresParam = true;
bool needsStringParameter = false;
std.needsStringParameter = false;
if (comparisonData.IsParenthesis)
{
if (comparisonData.Parenthesis == esParenthesis.Open)
{
sql += "(";
}
else
{
sql += ")";
}
continue;
}
if (comparisonData.IsConjunction)
{
switch (comparisonData.Conjunction)
{
case esConjunction.And: sql += " AND "; break;
case esConjunction.Or: sql += " OR "; break;
case esConjunction.AndNot: sql += " AND NOT "; break;
case esConjunction.OrNot: sql += " OR NOT "; break;
}
continue;
}
Dictionary <string, OracleParameter> types = null;
if (comparisonData.Column.Query != null)
{
IDynamicQuerySerializableInternal iLocalQuery = comparisonData.Column.Query as IDynamicQuerySerializableInternal;
types = Cache.GetParameters(iLocalQuery.DataID, (esProviderSpecificMetadata)iLocalQuery.ProviderMetadata, (esColumnMetadataCollection)iLocalQuery.Columns);
}
if (comparisonData.IsLiteral)
{
if (comparisonData.Column.Name[0] == '<')
{
sql += comparisonData.Column.Name.Substring(1, comparisonData.Column.Name.Length - 2);
}
else
{
sql += comparisonData.Column.Name;
}
continue;
}
if (comparisonData.ComparisonColumn.Name == null)
{
subQuery = comparisonData.Value as esDynamicQuerySerializable;
if (subQuery == null)
{
if (comparisonData.Column.Name != null)
{
IDynamicQuerySerializableInternal iColQuery = comparisonData.Column.Query as IDynamicQuerySerializableInternal;
esColumnMetadataCollection columns = (esColumnMetadataCollection)iColQuery.Columns;
compareTo = Delimiters.Param + columns[comparisonData.Column.Name].PropertyName + (++std.pindex).ToString();
}
else
{
compareTo = Delimiters.Param + "Expr" + (++std.pindex).ToString();
}
}
else
{
// It's a sub query
compareTo = GetSubquerySearchCondition(subQuery) + " (" + BuildQuery(std, subQuery) + ") ";
requiresParam = false;
}
}
else
{
compareTo = GetColumnName(comparisonData.ComparisonColumn);
requiresParam = false;
}
switch (comparisonData.Operand)
{
case esComparisonOperand.Exists:
sql += " EXISTS" + compareTo;
break;
case esComparisonOperand.NotExists:
sql += " NOT EXISTS" + compareTo;
break;
//-----------------------------------------------------------
// Comparison operators, left side vs right side
//-----------------------------------------------------------
case esComparisonOperand.Equal:
if (comparisonData.ItemFirst)
{
sql += ApplyWhereSubOperations(std, query, comparisonData) + " = " + compareTo;
}
else
{
sql += compareTo + " = " + ApplyWhereSubOperations(std, query, comparisonData);
}
break;
case esComparisonOperand.NotEqual:
if (comparisonData.ItemFirst)
{
sql += ApplyWhereSubOperations(std, query, comparisonData) + " <> " + compareTo;
}
else
{
sql += compareTo + " <> " + ApplyWhereSubOperations(std, query, comparisonData);
}
break;
case esComparisonOperand.GreaterThan:
if (comparisonData.ItemFirst)
{
sql += ApplyWhereSubOperations(std, query, comparisonData) + " > " + compareTo;
}
else
{
sql += compareTo + " > " + ApplyWhereSubOperations(std, query, comparisonData);
}
break;
case esComparisonOperand.LessThan:
if (comparisonData.ItemFirst)
{
sql += ApplyWhereSubOperations(std, query, comparisonData) + " < " + compareTo;
}
else
{
sql += compareTo + " < " + ApplyWhereSubOperations(std, query, comparisonData);
}
break;
case esComparisonOperand.LessThanOrEqual:
if (comparisonData.ItemFirst)
{
sql += ApplyWhereSubOperations(std, query, comparisonData) + " <= " + compareTo;
}
else
{
sql += compareTo + " <= " + ApplyWhereSubOperations(std, query, comparisonData);
}
break;
case esComparisonOperand.GreaterThanOrEqual:
if (comparisonData.ItemFirst)
{
sql += ApplyWhereSubOperations(std, query, comparisonData) + " >= " + compareTo;
}
else
{
sql += compareTo + " >= " + ApplyWhereSubOperations(std, query, comparisonData);
}
break;
case esComparisonOperand.Like:
string esc = comparisonData.LikeEscape.ToString();
if (String.IsNullOrEmpty(esc) || esc == "\0")
{
sql += ApplyWhereSubOperations(std, query, comparisonData) + " LIKE " + compareTo;
needsStringParameter = true;
}
else
{
sql += ApplyWhereSubOperations(std, query, comparisonData) + " LIKE " + compareTo;
sql += " ESCAPE '" + esc + "'";
needsStringParameter = true;
}
break;
case esComparisonOperand.NotLike:
esc = comparisonData.LikeEscape.ToString();
if (String.IsNullOrEmpty(esc) || esc == "\0")
{
sql += ApplyWhereSubOperations(std, query, comparisonData) + " NOT LIKE " + compareTo;
needsStringParameter = true;
}
else
{
sql += ApplyWhereSubOperations(std, query, comparisonData) + " NOT LIKE " + compareTo;
sql += " ESCAPE '" + esc + "'";
needsStringParameter = true;
}
break;
case esComparisonOperand.Contains:
sql += " CONTAINS(" + GetColumnName(comparisonData.Column) +
", " + compareTo + ")";
needsStringParameter = true;
break;
case esComparisonOperand.IsNull:
sql += ApplyWhereSubOperations(std, query, comparisonData) + " IS NULL";
requiresParam = false;
break;
case esComparisonOperand.IsNotNull:
sql += ApplyWhereSubOperations(std, query, comparisonData) + " IS NOT NULL";
requiresParam = false;
break;
case esComparisonOperand.In:
case esComparisonOperand.NotIn:
{
if (subQuery != null)
{
// They used a subquery for In or Not
sql += ApplyWhereSubOperations(std, query, comparisonData);
sql += (comparisonData.Operand == esComparisonOperand.In) ? " IN" : " NOT IN";
sql += compareTo;
}
else
{
comma = String.Empty;
if (comparisonData.Operand == esComparisonOperand.In)
{
sql += ApplyWhereSubOperations(std, query, comparisonData) + " IN (";
}
else
{
sql += ApplyWhereSubOperations(std, query, comparisonData) + " NOT IN (";
}
foreach (object oin in comparisonData.Values)
{
string str = oin as string;
if (str != null)
{
// STRING
sql += comma + "'" + str + "'";
comma = ",";
}
else if (null != oin as System.Collections.IEnumerable)
{
// LIST OR COLLECTION OF SOME SORT
System.Collections.IEnumerable enumer = oin as System.Collections.IEnumerable;
if (enumer != null)
{
System.Collections.IEnumerator iter = enumer.GetEnumerator();
while (iter.MoveNext())
{
object o = iter.Current;
string soin = o as string;
if (soin != null)
{
sql += comma + "'" + soin + "'";
}
else
{
sql += comma + Convert.ToString(o);
}
comma = ",";
}
}
}
else
{
// NON STRING OR LIST
sql += comma + Convert.ToString(oin);
comma = ",";
}
}
sql += ") ";
requiresParam = false;
}
}
break;
case esComparisonOperand.Between:
OracleCommand sqlCommand = std.cmd as OracleCommand;
sqlCommand.BindByName = true;
sql += ApplyWhereSubOperations(std, query, comparisonData) + " BETWEEN ";
sql += compareTo;
if (comparisonData.ComparisonColumn.Name == null)
{
OracleParameter p = new OracleParameter(compareTo, comparisonData.BetweenBegin);
sqlCommand.Parameters.Add(p);
}
if (comparisonData.ComparisonColumn2.Name == null)
{
IDynamicQuerySerializableInternal iColQuery = comparisonData.Column.Query as IDynamicQuerySerializableInternal;
esColumnMetadataCollection columns = (esColumnMetadataCollection)iColQuery.Columns;
compareTo = Delimiters.Param + columns[comparisonData.Column.Name].PropertyName + (++std.pindex).ToString();
sql += " AND " + compareTo;
OracleParameter p = new OracleParameter(compareTo, comparisonData.BetweenEnd);
sqlCommand.Parameters.Add(p);
}
else
{
sql += " AND " + Delimiters.ColumnOpen + comparisonData.ComparisonColumn2 + Delimiters.ColumnClose;
}
requiresParam = false;
break;
}
if (requiresParam)
{
OracleParameter p;
if (comparisonData.Column.Name != null)
{
p = types[comparisonData.Column.Name];
p = Cache.CloneParameter(p);
p.ParameterName = compareTo;
p.Value = comparisonData.Value;
if (needsStringParameter)
{
p.DbType = DbType.String;
}
else if (std.needsIntegerParameter)
{
p.DbType = DbType.Int32;
}
}
else
{
p = new OracleParameter(compareTo, comparisonData.Value);
}
std.cmd.Parameters.Add(p);
}
first = false;
}
}
// Kind of a hack here, I should probably pull this out and put it in build query ... and do it only for the WHERE
if (query.es.Top >= 0 && prefix == " WHERE ")
{
if (!first)
{
sql += " AND ";
}
else
{
sql += " WHERE ";
}
sql += "ROWNUM <= " + query.es.Top.ToString();
}
return(sql);
}
internal StringEnumerator(StringCollection mappings)
{
_temp = (IEnumerable)(mappings);
_baseEnumerator = _temp.GetEnumerator();
}
/// <summary>
/// Called by the ASP.NET page framework to notify server controls that use composition-based implementation to create any child controls they contain in preparation for posting back or rendering.
/// </summary>
protected override int CreateChildControls(System.Collections.IEnumerable dataSource, bool dataBinding)
{
int pos = 0;
if (dataBinding)
{
//Instantiate the Header template (if exists)
if (m_headerTemplate != null)
{
Control headerItem = new Control();
m_headerTemplate.InstantiateIn(headerItem);
Controls.Add(headerItem);
}
if (dataSource != null)
{
foreach (object o in dataSource)
{
EmployeeDB.BLL.EmployeeSkills entity = o as EmployeeDB.BLL.EmployeeSkills;
EmployeeSkillsItem container = new EmployeeSkillsItem(entity);
if (m_itemTemplate != null && (pos % 2) == 0)
{
m_itemTemplate.InstantiateIn(container);
if (m_seperatorTemplate != null)
{
m_seperatorTemplate.InstantiateIn(container);
}
}
else
{
if (m_altenateItemTemplate != null)
{
m_altenateItemTemplate.InstantiateIn(container);
if (m_seperatorTemplate != null)
{
m_seperatorTemplate.InstantiateIn(container);
}
}
else if (m_itemTemplate != null)
{
m_itemTemplate.InstantiateIn(container);
if (m_seperatorTemplate != null)
{
m_seperatorTemplate.InstantiateIn(container);
}
}
else
{
// no template !!!
}
}
Controls.Add(container);
container.DataBind();
pos++;
}
}
//Instantiate the Footer template (if exists)
if (m_footerTemplate != null)
{
Control footerItem = new Control();
m_footerTemplate.InstantiateIn(footerItem);
Controls.Add(footerItem);
}
}
return(pos);
}
public static void SetItems(this ItemsControl itemsControl, System.Collections.IEnumerable enumerable) => itemsControl.Items = enumerable;
public static string ToStringList(System.Collections.IEnumerable names)
{
return(Builtins.join(names.Cast <object>().Select(o => DisplayStringFor(o)).OrderBy(_ => _), ", "));
}
/// <summary>
/// Asserts that the subset contains the superset.
/// </summary>
/// <param name="superset">The System.Collections.IEnumerable superset to be considered</param>
/// <param name="subset">The System.Collections.IEnumerable subset to be considered</param>
/// <param name="message">The message that will be displayed on failure</param>
/// <param name="args">Arguments to be used in formatting the message</param>
public static void IsSupersetOf(System.Collections.IEnumerable superset, System.Collections.IEnumerable subset, string message, params object[] args)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.IsSupersetOf(superset, subset, message, args));
}
public System.Collections.ICollection GetHistory(string szFile)
{
VersionControlServer sourceControl;
GetPathAndScope(szFile, out sourceControl);
// Retrieve and print the label history for the file.
VersionControlLabel[] labels = null;
ChangeSetLabelObject[] ChangesetLabelObjects = new ChangeSetLabelObject[10000];
Item targetFile = null;
System.Collections.IEnumerable history = null;
System.Collections.SortedList slChangeSetsAndLabels = new System.Collections.SortedList();
System.Collections.SortedList slChangeSets = new System.Collections.SortedList();
try
{
targetFile = sourceControl.GetItem(szFile);
//Query labels seems to return labels that correspond to the file and nothing filtered related the version spec
//So we need to query everything and then filter ourselves.
//Hint: The there is a TimeSpan here because doing that is slow.
DateTime dtStart = DateTime.Now;
labels = sourceControl.QueryLabels(null, szFile, null, true, szFile, VersionSpec.Latest);
TimeSpan tsQueryLabels = DateTime.Now - dtStart;
history = sourceControl.QueryHistory(szFile,
VersionSpec.Latest,
0,
RecursionType.Full,
null,
null,
null,
10000,
true,
false);
TimeSpan tsAnotherTimeSpan = DateTime.Now - dtStart;
}
catch (TeamFoundationServerException e)
{
// We couldn't contact the server, the item wasn't found,
// or there was some other problem reported by the server,
// so we stop here.
System.Windows.Forms.MessageBox.Show(e.Message);
return(slChangeSets.Values);
}
if (labels.Length == 0)
{
Console.WriteLine("There are no labels for " + szFile);
return(slChangeSets.Values);
}
else
{
//first, sort all the changesets into a list
foreach (Changeset c in history)
{
ChangeSetLabels csl = new ChangeSetLabels();
csl.m_csChangeset = c;
slChangeSets[c.ChangesetId] = csl;
slChangeSetsAndLabels[c.CreationDate] = c;
}
foreach (VersionControlLabel l in labels)
{
slChangeSetsAndLabels[l.LastModifiedDate] = l;
}
}
return(slChangeSetsAndLabels.Values);
}
/// <summary>
/// Assert that an array, list or other collection is empty
/// </summary>
/// <param name="collection">An array, list or other collection implementing System.Collections.IEnumerable</param>
/// <param name="message">The message to be displayed on failure</param>
/// <param name="args">Arguments to be used in formatting the message</param>
public static void IsNotEmpty(System.Collections.IEnumerable collection, string message, params object[] args)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.IsNotEmpty(collection, message, args));
}
public override System.Web.Caching.CacheDependency GetCacheDependency(string virtualPath, System.Collections.IEnumerable virtualPathDependencies, DateTime utcStart)
{
return(base.GetCacheDependency(virtualPath, virtualPathDependencies, utcStart));
}
/// <summary>
/// Assert that an array, list or other collection is ordered
/// </summary>
/// <param name="collection">An array, list or other collection implementing System.Collections.IEnumerable</param>
/// <param name="comparer">A custom comparer to perform the comparisons</param>
/// <param name="message">The message to be displayed on failure</param>
/// <param name="args">Arguments to be used in formatting the message</param>
public static void IsOrdered(System.Collections.IEnumerable collection, System.Collections.IComparer comparer, string message, params object[] args)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.IsOrdered(collection, comparer, message, args));
}
public override string GetFileHash(string virtualPath, System.Collections.IEnumerable virtualPathDependencies)
{
return(base.GetFileHash(virtualPath, virtualPathDependencies));
}
/// <summary>
/// Asserts that expected and actual are exactly equal. The collections must have the same count,
/// and contain the exact same objects in the same order.
/// If comparer is not null then it will be used to compare the objects.
/// </summary>
/// <param name="expected">The first System.Collections.IEnumerable of objects to be considered</param>
/// <param name="actual">The second System.Collections.IEnumerable of objects to be considered</param>
/// <param name="comparer">The System.Collections.IComparer to use in comparing objects from each System.Collections.IEnumerable</param>
/// <param name="message">The message that will be displayed on failure</param>
/// <param name="args">Arguments to be used in formatting the message</param>
public static void AreEqual(System.Collections.IEnumerable expected, System.Collections.IEnumerable actual, System.Collections.IComparer comparer, string message, params object[] args)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.AreEqual(expected, actual, comparer, message, args));
}
/// <summary>
/// Asserts that all items contained in collection are of the type specified by expectedType.
/// </summary>
/// <param name="collection">System.Collections.IEnumerable containing objects to be considered</param>
/// <param name="expectedType">System.Type that all objects in collection must be instances of</param>
public static void AllItemsAreInstancesOfType(System.Collections.IEnumerable collection, System.Type expectedType)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(collection, expectedType));
}
/// <summary>
/// Disposes the wrapped instance if it implements IDisposable.
/// </summary>
/// <param name="disposing">Whether or not to dispose managed resources</param>
protected virtual void Dispose(bool disposing)
{
CallOrderUtilities.TryWrapArbitraryMethodCall(
() => this.Dispose(),
() =>
{
var d = this.underlyingImplementation as IDisposable;
if (d != null)
{
d.Dispose();
this.underlyingImplementation = null;
}
});
}
/// <summary>
/// Asserts that expected and actual are not exactly equal.
/// If comparer is not null then it will be used to compare the objects.
/// </summary>
/// <param name="expected">The first System.Collections.IEnumerable of objects to be considered</param>
/// <param name="actual">The second System.Collections.IEnumerable of objects to be considered</param>
/// <param name="comparer">The System.Collections.IComparer to use in comparing objects from each System.Collections.IEnumerable</param>
public static void AreNotEqual(System.Collections.IEnumerable expected, System.Collections.IEnumerable actual, System.Collections.IComparer comparer)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.AreNotEqual(expected, actual, comparer));
}
public Iterator( IEnumerable enumerable )
{
_enumerable = enumerable;
_iterator = enumerable.GetEnumerator();
_hasNext = _iterator.MoveNext();
}
/// <summary>
/// Asserts that expected and actual are not equivalent.
/// </summary>
/// <param name="expected">The first System.Collections.IEnumerable of objects to be considered</param>
/// <param name="actual">The second System.Collections.IEnumerable of objects to be considered</param>
public static void AreNotEquivalent(System.Collections.IEnumerable expected, System.Collections.IEnumerable actual)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.AreNotEquivalent(expected, actual));
}
private void graphicsLayer_MouseEnter(object sender, GraphicMouseEventArgs args)
{
mouseIsOver = true;
Graphic graphic = args.Graphic;
if (currentFeature != graphic) //Mouse entered a new feature
{
this.expanded = false;
currentFeature = graphic;
Point p = args.GetPosition(Parent as UIElement);
SetValue(Canvas.LeftProperty, p.X + HorizontalOffset);
SetValue(Canvas.TopProperty, p.Y + VerticalOffset);
this.DataContext = this.ItemsSource = graphic.Attributes;
if (!string.IsNullOrEmpty(TitleMember))
{
object title = null;
if (graphic.Attributes.ContainsKey(TitleMember))
title = string.Format("{0}", graphic.Attributes[TitleMember]);
else
{
string firstKey = null;
foreach (string key in graphic.Attributes.Keys)
{
if (firstKey == null) firstKey = key;
if (graphic.Attributes[key].GetType() == typeof(string))
{
title = graphic.Attributes[key] as string;
break;
}
}
if (title == null && !string.IsNullOrEmpty(firstKey))
title = string.Format("{0}", graphic.Attributes[firstKey]);
}
this.Title = title;
}
ChangeVisualState(false);
Visibility = Visibility.Collapsed;
}
if (Visibility == Visibility.Collapsed)
{
timer.Start(); //Delay showing maptip
}
}
/// <summary>
/// Asserts that expected and actual are not equivalent.
/// </summary>
/// <param name="expected">The first System.Collections.IEnumerable of objects to be considered</param>
/// <param name="actual">The second System.Collections.IEnumerable of objects to be considered</param>
/// <param name="message">The message that will be displayed on failure</param>
/// <param name="args">Arguments to be used in formatting the message</param>
public static void AreNotEquivalent(System.Collections.IEnumerable expected, System.Collections.IEnumerable actual, string message, params object[] args)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.AreNotEquivalent(expected, actual, message, args));
}
/// <summary>
/// Initializes a new instance of <see cref='XmlSchemaCompletionDataEnumerator'/>.
/// </summary>
public XmlSchemaCompletionDataEnumerator(XmlSchemaCompletionDataCollection mappings)
{
this.temp = ((System.Collections.IEnumerable)(mappings));
this.baseEnumerator = temp.GetEnumerator();
}
/// <summary>
/// Asserts that collection does not contain actual as an item.
/// </summary>
/// <param name="collection">System.Collections.IEnumerable of objects to be considered</param>
/// <param name="actual">Object that cannot exist within collection</param>
public static void DoesNotContain(System.Collections.IEnumerable collection, object actual)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.DoesNotContain(collection, actual));
}
protected override void RenderEnumerable(StringBuilder builder, VariableReference variable, IEnumerable variableValue, bool first)
{
bool firstElement = true;
foreach (object value in variableValue)
{
if (value == null)
continue;
RenderElement(builder, variable, value, first, firstElement);
firstElement = false;
}
}
/// <summary>
/// Asserts that collection does not contain actual as an item.
/// </summary>
/// <param name="collection">System.Collections.IEnumerable of objects to be considered</param>
/// <param name="actual">Object that cannot exist within collection</param>
/// <param name="message">The message that will be displayed on failure</param>
/// <param name="args">Arguments to be used in formatting the message</param>
public static void DoesNotContain(System.Collections.IEnumerable collection, object actual, string message, params object[] args)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.DoesNotContain(collection, actual, message, args));
}
private void CreatePermutaionList(string[] pStratvarList)
{
int i = 0;
Frequency.SelectClauses = new List<string>();
if (pStratvarList != null)
{
List<DataRow> Rows = this.Context.GetDataRows(null);
foreach (string StratVar in pStratvarList)
{
Frequency.PermutationList.Add(StratVar, new List<object>());
}
foreach (DataRow R in Rows)
{
foreach (string StratVar in pStratvarList)
{
bool isFound = false;
for (i = 0; i < Frequency.PermutationList[StratVar].Count; i++)
{
if (CompareEqual(Frequency.PermutationList[StratVar][i], R[StratVar]))
{
isFound = true;
break;
}
}
if (!isFound)
{
Frequency.PermutationList[StratVar].Add(R[StratVar]);
}
}
}
EnumerablePermuter_Freq EP = new EnumerablePermuter_Freq(this.Context.Columns, EnumerablePermuter_Freq.RunModeEnum.SelectClauses, ref this.StratvarList, ref Frequency.SelectClauses);
System.Collections.IEnumerable[] PL = new System.Collections.IEnumerable[Frequency.PermutationList.Count];
i = 0;
foreach (KeyValuePair<string, List<object>> Key in Frequency.PermutationList)
{
PL[i++] = Key.Value;
}
EP.VisitAll(PL);
}
if (Frequency.SelectClauses.Count == 0)
{
Frequency.SelectClauses.Add("");
}
}
/// <summary>
/// Asserts that all items contained in collection are of the type specified by expectedType.
/// </summary>
/// <param name="collection">System.Collections.IEnumerable containing objects to be considered</param>
/// <param name="expectedType">System.Type that all objects in collection must be instances of</param>
/// <param name="message">The message that will be displayed on failure</param>
/// <param name="args">Arguments to be used in formatting the message</param>
public static void AllItemsAreInstancesOfType(System.Collections.IEnumerable collection, System.Type expectedType, string message, params object[] args)
{
Assert.Multiple(() => NUnit.Framework.CollectionAssert.AllItemsAreInstancesOfType(collection, expectedType, message, args));
}
public TreeListAdapter(System.Collections.IEnumerable list)
{
_list = list;
}
/// <summary>
/// 转换表达式
/// </summary>
/// <param name="expression">表达式</param>
/// <param name="isIn"></param>
private void convertCall(MethodCallExpression expression, bool isIn)
{
System.Collections.ObjectModel.ReadOnlyCollection <Expression> arguments = expression.Arguments;
System.Collections.IEnumerable values = (System.Collections.IEnumerable)arguments[1].GetConstant();
if (values != null)
{
LeftArray <object> array = new LeftArray <object>();
foreach (object value in values)
{
array.Add(value);
}
switch (array.Length)
{
case 0: break;
case 1:
Expression leftExpression = arguments[0];
if (array[0] == null)
{
convertIsSimple(leftExpression);
SqlStream.SimpleWriteNotNull(isIn ? " is null" : " is not null");
}
else
{
convertIsSimple(leftExpression);
if (isIn)
{
SqlStream.Write('=');
}
else
{
SqlStream.Write('<');
SqlStream.Write('>');
}
convertConstant(array[0]);
}
return;
default:
Convert(arguments[0]);
SqlStream.SimpleWriteNotNull(isIn ? " In(" : " Not In(");
Action <CharStream, object> toString = ConstantConverter[array[0].GetType()];
int index = 0;
if (toString == null)
{
foreach (object value in array)
{
if (index == 0)
{
index = 1;
}
else
{
SqlStream.Write(',');
}
ConstantConverter.Convert(SqlStream, value.ToString());
}
}
else
{
foreach (object value in array)
{
if (index == 0)
{
index = 1;
}
else
{
SqlStream.Write(',');
}
toString(SqlStream, value);
}
}
SqlStream.Write(')');
return;
}
}
SqlStream.SimpleWriteNotNull(isIn ? "(1=0)" : "(1=1)");
}