///////////////////////////////////////////////////////////////////////
public string ToString(
string separator,
string pattern,
bool noCase
)
{
//
// HACK: The caller of this method should NOT rely upon the
// resulting string being a well-formed list as this
// is no longer guaranteed.
//
if (this.Count == 0)
{
return(String.Empty);
}
else if (this.Count == 1)
{
Result result = this[0];
if (result != null)
{
return(result.ToString());
}
}
return(GenericOps <Result> .ListToString(
this, Index.Invalid, Index.Invalid, ToStringFlags.None,
separator, pattern, noCase));
}
///////////////////////////////////////////////////////////////////////////////////////////////
public string ToString(string pattern, bool noCase)
{
StringList list = new StringList(this.Keys);
return(GenericOps <string> .ListToString(list, Index.Invalid, Index.Invalid,
ToStringFlags.None, Characters.Space.ToString(), pattern, noCase));
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region IEqualityComparer<IScriptLocation> Members
public bool Equals(
IScriptLocation x,
IScriptLocation y
)
{
return(GenericOps <IScriptLocation> .EqualityComparerEquals(this, x, y));
}
public bool Equals(
byte[] x,
byte[] y
)
{
return(GenericOps <byte> .Equals(x, y));
}
///////////////////////////////////////////////////////////////////////
#region ToString Methods
public ReturnCode ToList(
string pattern,
bool noCase,
bool fullName,
bool qualified,
ref StringList list,
ref Result error
)
{
StringList inputList = new StringList();
foreach (Type type in this)
{
if (type != null)
{
inputList.Add(FormatOps.QualifiedAndOrFullName(
type, fullName, qualified, false));
}
}
if (list == null)
{
list = new StringList();
}
return(GenericOps <string> .FilterList(
inputList, list, Index.Invalid, Index.Invalid,
ToStringFlags.None, pattern, noCase, ref error));
}
///////////////////////////////////////////////////////////////////////
#region Error Message Methods
public static string ToEnglish(
IDictionary <string, string> dictionary
)
{
return(GenericOps <string> .ListToEnglish(
dictionary, ", ", Characters.Space.ToString(), "or "));
}
///////////////////////////////////////////////////////////////////////
public string ToString(
string pattern,
bool noCase,
bool qualified
)
{
if (qualified)
{
StringList list = new StringList();
foreach (Type type in this)
{
if (type != null)
{
list.Add(FormatOps.QualifiedName(type));
}
}
return(GenericOps <string> .ListToString(
list, Index.Invalid, Index.Invalid, ToStringFlags.None,
Characters.Space.ToString(), pattern, noCase));
}
else
{
return(GenericOps <Type> .ListToString(
this, Index.Invalid, Index.Invalid, ToStringFlags.None,
Characters.Space.ToString(), pattern, noCase));
}
}
///////////////////////////////////////////////////////////////////////
public override int GetHashCode()
{
return(CommonOps.HashCodes.Combine(
GenericOps <T1> .GetHashCode(this.X),
GenericOps <T2> .GetHashCode(this.Y),
GenericOps <T3> .GetHashCode(this.Z)));
}
///////////////////////////////////////////////////////////////////////////////////////////////
public string ToString(
string pattern,
bool noCase
)
{
return(GenericOps <char> .ListToString(this, Index.Invalid, Index.Invalid,
ToStringFlags.None, Characters.Space.ToString(), pattern, noCase));
}
///////////////////////////////////////////////////////////////////////
public string ToString(
string separator,
string pattern,
bool noCase
)
{
return(GenericOps <IClientData> .ListToString(
this, ToStringFlags.None, separator, pattern, noCase));
}
///////////////////////////////////////////////////////////////////////
public string ToString(
IOption option
)
{
return(GenericOps <string> .ListToString(
ToList(option), _Constants.Index.Invalid,
_Constants.Index.Invalid, ToStringFlags.None,
Characters.Space.ToString(), null, false));
}
///////////////////////////////////////////////////////////////////////
public ReturnCode ToList(
AliasFlags hasFlags,
AliasFlags notHasFlags,
bool hasAll,
bool notHasAll,
string pattern,
bool noCase,
ref StringList list,
ref Result error
)
{
StringList inputList;
//
// NOTE: If no flags were supplied, we do not bother filtering on
// them.
//
if ((hasFlags == AliasFlags.None) &&
(notHasFlags == AliasFlags.None))
{
inputList = new StringList(this.Keys);
}
else
{
inputList = new StringList();
foreach (KeyValuePair <string, _Wrappers.Alias> pair in this)
{
IAlias alias = pair.Value as IAlias;
if (alias == null)
{
continue;
}
if (((hasFlags == AliasFlags.None) ||
FlagOps.HasFlags(
alias.AliasFlags, hasFlags, hasAll)) &&
((notHasFlags == AliasFlags.None) ||
!FlagOps.HasFlags(
alias.AliasFlags, notHasFlags, notHasAll)))
{
inputList.Add(pair.Key);
}
}
}
if (list == null)
{
list = new StringList();
}
return(GenericOps <string> .FilterList(
inputList, list, Index.Invalid, Index.Invalid,
ToStringFlags.None, pattern, noCase, ref error));
}
///////////////////////////////////////////////////////////////////////
public string KeysToString(
string separator
)
{
StringList list = new StringList(this.Keys);
return(GenericOps <string> .ListToString(
list, Index.Invalid, Index.Invalid, ToStringFlags.None,
separator, null, false));
}
///////////////////////////////////////////////////////////////////////
#region ToString Methods
public string ToString(
string pattern,
bool noCase
)
{
return(GenericOps <ArgumentInfo> .ListToString(
new ArgumentInfoList(this.Values),
Index.Invalid, Index.Invalid, ToStringFlags.None,
Characters.Space.ToString(), pattern, noCase));
}
///////////////////////////////////////////////////////////////////////
#region ToString Methods
public string ToString(
string pattern,
bool noCase
)
{
// CheckDisposed();
return(GenericOps <ICallFrame> .ListToString(
this, Index.Invalid, Index.Invalid, ToStringFlags.None,
Characters.Space.ToString(), pattern, noCase));
}
///////////////////////////////////////////////////////////////////////
public string ValuesToString(
string pattern,
RegexOptions regExOptions
)
{
StringList list = new StringList(this.Values);
return(GenericOps <string> .ListToString(
list, Index.Invalid, Index.Invalid, ToStringFlags.None,
Characters.Space.ToString(), pattern, regExOptions));
}
///////////////////////////////////////////////////////////////////////
#region ToString Methods
public virtual string ToString(
string pattern,
bool noCase
)
{
StringList list = new StringList(this.Keys);
return(GenericOps <string> .ListToString(
list, Index.Invalid, Index.Invalid, ToStringFlags.None,
ElementSeparator, pattern, noCase));
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region Dead Code
#if DEAD_CODE
public string KeysAndValuesToString(
string pattern,
RegexOptions regExOptions
)
{
StringList list = GenericOps <string, ScriptLocationIntDictionary> .KeysAndValues(
this, false, true, true, MatchMode.RegExp, pattern, null, null, null,
null, false, regExOptions) as StringList;
return(GenericOps <string> .ListToString(list, Index.Invalid, Index.Invalid,
ToStringFlags.None, Characters.Space.ToString(), null, false));
}
///////////////////////////////////////////////////////////////////////
public IStringList ToList(
string pattern,
bool empty,
bool noCase
)
{
StringPairList inputList;
StringPairList outputList = new StringPairList();
if (empty)
{
inputList = this;
}
else
{
inputList = new StringPairList();
foreach (IPair <string> element in this)
{
if (element == null)
{
continue;
}
if (String.IsNullOrEmpty(element.X) &&
String.IsNullOrEmpty(element.Y))
{
continue;
}
inputList.Add(element);
}
}
ReturnCode code;
Result error = null;
code = GenericOps <IPair <string> > .FilterList(
inputList, outputList, Index.Invalid, Index.Invalid,
ToStringFlags.None, pattern, noCase, ref error);
if (code != ReturnCode.Ok)
{
DebugOps.Complain(code, error);
//
// TODO: Return null in the error case here?
//
outputList = null;
}
return(outputList);
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region Public Methods
public string ToString(
string pattern,
bool noCase
)
{
StringList list = GenericOps <long, string> .KeysAndValues(
this, false, true, true, StringOps.DefaultMatchMode, pattern, null,
KeyFormat, null, null, noCase, RegexOptions.None) as StringList;
return(GenericOps <string> .ListToString(list, Index.Invalid, Index.Invalid,
ToStringFlags.None, Characters.Space.ToString(), null, false));
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region System.Object Overrides
public override bool Equals(object obj)
{
Number number = obj as Number;
if (number != null)
{
return(GenericOps <object> .Equals(this.Value, number.Value));
}
else
{
return(false);
}
}
///////////////////////////////////////////////////////////////////////
public string ValuesToString(
MatchMode mode,
string pattern,
bool noCase,
RegexOptions regExOptions
)
{
StringList list = GenericOps <string, object> .KeysAndValues(
this, false, false, true, mode, null, pattern, null, null,
null, noCase, regExOptions) as StringList;
return(GenericOps <string> .ListToString(
list, Index.Invalid, Index.Invalid, ToStringFlags.None,
Characters.Space.ToString(), null, false));
}
///////////////////////////////////////////////////////////////////////
#region System.Object Overrides
public override bool Equals(
object obj
)
{
IAnyPair <T1, T2> anyPair = obj as IAnyPair <T1, T2>;
if (anyPair != null)
{
return(GenericOps <T1> .Equals(this.X, anyPair.X) &&
GenericOps <T2> .Equals(this.Y, anyPair.Y));
}
else
{
return(false);
}
}
///////////////////////////////////////////////////////////////////////
#region System.Object Overrides
public override bool Equals(
object obj
)
{
IAnyTriplet <T1, T2, T3> anyTriplet = obj as IAnyTriplet <T1, T2, T3>;
if (anyTriplet != null)
{
return(GenericOps <T1> .Equals(this.X, anyTriplet.X) &&
GenericOps <T2> .Equals(this.Y, anyTriplet.Y) &&
GenericOps <T3> .Equals(this.Z, anyTriplet.Z));
}
else
{
return(false);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region Dead Code
#if DEAD_CODE
private ReturnCode ToList(
string pattern,
bool noCase,
ref StringList list,
ref Result error
)
{
StringList inputList = new StringList(this.Keys);
if (list == null)
{
list = new StringList();
}
return(GenericOps <string> .FilterList(inputList, list, Index.Invalid,
Index.Invalid, ToStringFlags.None, pattern, noCase, ref error));
}
///////////////////////////////////////////////////////////////////////
#region Public Methods
public override string ToString(
string pattern,
bool noCase
)
{
StringList list = new StringList();
foreach (_Wrappers.Plugin item in this.Values)
{
if (item != null)
{
list.Add(StringList.MakeList(item.FileName, item.Name));
}
}
return(GenericOps <string> .ListToString(
list, Index.Invalid, Index.Invalid, ToStringFlags.None,
Characters.Space.ToString(), pattern, noCase));
}
///////////////////////////////////////////////////////////////////////
public string ToString(
string separator,
string pattern,
bool noCase
)
{
#if CACHE_ARGUMENTLIST_TOSTRING
bool canUseCachedString = CanUseCachedString(
ToStringFlags.None, separator, pattern, noCase);
if (canUseCachedString && (@string != null))
{
#if CACHE_STATISTICS
Interlocked.Increment(
ref cacheCounts[(int)CacheCountType.Hit]);
#endif
return(@string);
}
#if CACHE_STATISTICS
Interlocked.Increment(
ref cacheCounts[(int)CacheCountType.Miss]);
#endif
#endif
string result = GenericOps <Argument> .ListToString(
this, Index.Invalid, Index.Invalid, ToStringFlags.None,
separator, pattern, noCase);
#if CACHE_ARGUMENTLIST_TOSTRING
if (canUseCachedString)
{
@string = result;
}
#endif
return(result);
}
///////////////////////////////////////////////////////////////////////
public string ToString(
string separator,
string pattern,
bool empty,
bool noCase
)
{
if (empty)
{
return(GenericOps <IPair <string> > .ListToString(
this, Index.Invalid, Index.Invalid, ToStringFlags.None,
separator, pattern, noCase));
}
else
{
StringPairList result = new StringPairList();
foreach (IPair <string> element in this)
{
if (element == null)
{
continue;
}
if (String.IsNullOrEmpty(element.X) &&
String.IsNullOrEmpty(element.Y))
{
continue;
}
result.Add(element);
}
return(GenericOps <IPair <string> > .ListToString(
result, Index.Invalid, Index.Invalid, ToStringFlags.None,
separator, pattern, noCase));
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
public int GetHashCode(
IScriptLocation obj
)
{
return(GenericOps <IScriptLocation> .EqualityComparerGetHashCode(this, obj));
}
///////////////////////////////////////////////////////////////////////
public string ToString(string pattern, bool noCase)
{
return(GenericOps <IAnyPair <Interpreter, IClientData> > .ListToString(
this, Index.Invalid, Index.Invalid, ToStringFlags.None,
Characters.Space.ToString(), pattern, noCase));
}
