public override bool CanConvertFrom(Type /*!*/ fromType, ParameterWrapper /*!*/ toParameter, NarrowingLevel level)
{
Type toType = toParameter.Type;
if (base.CanConvertFrom(fromType, toParameter, level))
{
return(true);
}
// blocks:
if (fromType == typeof(MissingBlockParam))
{
return(toType == typeof(BlockParam) && !toParameter.ProhibitNull);
}
if (fromType == typeof(BlockParam) && toType == typeof(MissingBlockParam))
{
return(true);
}
// protocol conversions:
if (toParameter.ParameterInfo != null && toParameter.ParameterInfo.IsDefined(typeof(DefaultProtocolAttribute), false))
{
// any type is potentially convertible, except for nil if [NotNull] is used:
return(fromType != typeof(Null) || !toParameter.ProhibitNull);
}
return(false);
}
public static IReadOnlyCollection <SyntaxKind> GetModifiers(this ParameterWrapper parameter, bool isExtensionMethod)
{
var modifierList = new List <SyntaxKind>(6);
if (isExtensionMethod)
{
modifierList.Add(SyntaxKind.ThisKeyword);
}
switch (parameter.ReferenceKind)
{
case ParameterReferenceKind.In:
modifierList.Add(SyntaxKind.InKeyword);
break;
case ParameterReferenceKind.Out:
modifierList.Add(SyntaxKind.OutKeyword);
break;
case ParameterReferenceKind.Ref:
modifierList.Add(SyntaxKind.RefKeyword);
break;
}
if (parameter.Attributes.HasKnownAttribute(KnownAttribute.ParamArray))
{
modifierList.Add(SyntaxKind.ParamsKeyword);
}
return(modifierList);
}
public override Candidate SelectBestConversionFor(DynamicMetaObject arg, ParameterWrapper candidateOne, ParameterWrapper candidateTwo, NarrowingLevel level)
{
Candidate basePreferred = base.SelectBestConversionFor(arg, candidateOne, candidateTwo, level);
if (basePreferred == Candidate.One || basePreferred == Candidate.Two)
{
return(basePreferred);
}
bool isBytesLikeOne = IsBytesLikeParameter(candidateOne);
bool isBytesLikeTwo = IsBytesLikeParameter(candidateTwo);
if (isBytesLikeOne)
{
if (isBytesLikeTwo)
{
return(basePreferred);
}
if (candidateTwo.Type.IsInterface)
{
return(Candidate.One);
}
}
else if (isBytesLikeTwo)
{
if (candidateOne.Type.IsInterface)
{
return(Candidate.Two);
}
}
return(basePreferred);
}
public override void save()
{
if (this._wrappedOperation == null)
{
this._wrappedOperation = this._factory._modelFactory.createNewElement <Operation>(this._owner._wrappedClass, this._name);
this._wrappedOperation.setStereotype(getStereotype());
}
if (this._wrappedOperation != null)
{
this._wrappedOperation.save();
this.isOverridden = this.isOverridden;
//get the corresponding columns from this table
this.involvedColumns = this.ownerTable.columns.Where(x => _involvedColumns.Any(y => y.name == x.name)).ToList();
if (this._wrappedOperation != null)
{
//first remove all existing parameters
this._wrappedOperation.ownedParameters = new HashSet <UML.Classes.Kernel.Parameter>();
foreach (var column in _involvedColumns)
{
{
ParameterWrapper parameter = this._wrappedOperation.model.factory.createNewElement <Parameter>(this._wrappedOperation, column.name) as ParameterWrapper;
parameter.type = ((Column)column)._wrappedattribute.type;
//TODO: this would be nicer if we could keep the parameters in memory and not save them directly
parameter.save();
}
}
}
}
}
protected override void AfterLoading()
{
//новый продукт
var block = new ProductBlockWrapper(new ProductBlock());
Item.Product = new ProductWrapper(new Product())
{
ProductBlock = block
};
//параметры продукта
_parameter = new ParameterWrapper(new Parameter());
var group = UnitOfWork.Repository <ParameterGroup>().GetById(GlobalAppProperties.Actual.NewProductParameterGroup.Id);
_parameter.ParameterGroup = new ParameterGroupWrapper(group);
var parameterBase = UnitOfWork.Repository <Parameter>().GetById(GlobalAppProperties.Actual.NewProductParameter.Id);
var relation = new ParameterRelation();
relation.RequiredParameters.Add(parameterBase);
_parameter.ParameterRelations.Add(new ParameterRelationWrapper(relation));
var parameters = parameterBase.Paths().First().Parameters.Select(x => new ParameterWrapper(x)).ToList();
parameters.Add(_parameter);
parameters.ForEach(x => block.Parameters.Add(x));
Item.PropertyChanged += ItemOnPropertyChanged;
base.AfterLoading();
}
private bool HasExplicitProtocolConversion(ParameterWrapper /*!*/ parameter)
{
return
(parameter.ParameterInfo != null &&
parameter.ParameterInfo.IsDefined(typeof(DefaultProtocolAttribute), false) &&
!parameter.IsParamsArray); // default protocol doesn't apply on param-array/dict itself, only on the expanded parameters
}
public void PopulateItems()
{
var e = GetInputElement();
if (e != null)
{
var items = new List <ParameterWrapper>();
// add instance parameters
items.AddRange(GetParameters(e, "Instance"));
// add type parameters
if (e.CanHaveTypeAssigned())
{
var et = DocumentManager.Instance.CurrentDBDocument.GetElement(e.GetTypeId());
if (et != null)
{
items.AddRange(GetParameters(et, "Type"));
}
}
ItemsCollection = new ObservableCollection <ParameterWrapper>(items.OrderBy(x => x.Name));
}
if (SelectedItem == null)
{
SelectedItem = ItemsCollection.FirstOrDefault();
}
}
public virtual bool CanConvertFrom(Type fromType, ParameterWrapper toParameter, NarrowingLevel level)
{
Assert.NotNull(fromType, toParameter);
Type toType = toParameter.Type;
if (fromType == Null.Type)
{
if (toParameter.ProhibitNull)
{
return(false);
}
if (toType.IsGenericType && toType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
return(true);
}
if (!toType.IsValueType)
{
return(true);
}
}
if (fromType == toType)
{
return(true);
}
return(CanConvertFrom(fromType, toType, toParameter.ProhibitNull, level));
}
private void Connectors_CollectionChanged(object sender, NotifyCollectionChangedEventArgs e)
{
if (e.Action == NotifyCollectionChangedAction.Remove)
{
ItemsCollection.Clear();
SelectedItem = null;
OnRequestChangeBuiltInParamSelector();
}
else
{
OnRequestChangeBuiltInParamSelector();
}
}
private object GetFromHeaders(ParameterWrapper parameter)
{
if (!Request.Headers.Contains(parameter.Name))
{
return(null);
}
var vals = Request.Headers.GetValues(parameter.Name);
if (vals.Count() <= 1)
{
return(vals.SingleOrDefault());
}
throw new InvalidCastException("Not currently able to deal with collections...");
}
private ParameterWrapper DeserializeValue(string val)
{
try
{
var name = val.Split('+')[0];
var bipName = val.Split('+')[1];
return(SelectedItem = new ParameterWrapper {
Name = name, BipName = bipName
});
}
catch
{
return(SelectedItem = new ParameterWrapper {
Name = "None", BipName = "None"
});
}
}
public override Candidate SelectBestConversionFor(Type /*!*/ actualType, ParameterWrapper /*!*/ candidateOne, ParameterWrapper /*!*/ candidateTwo, NarrowingLevel level)
{
Type typeOne = candidateOne.Type;
Type typeTwo = candidateTwo.Type;
if (actualType == typeof(Null))
{
// if nil is passed as a block argument prefer BlockParam over missing block;
if (typeOne == typeof(BlockParam) && typeTwo == typeof(MissingBlockParam))
{
return(Candidate.One);
}
if (typeOne == typeof(MissingBlockParam) && typeTwo == typeof(BlockParam))
{
return(Candidate.Two);
}
}
else
{
if (actualType == typeOne && candidateOne.ProhibitNull)
{
return(Candidate.One);
}
if (actualType == typeTwo && candidateTwo.ProhibitNull)
{
return(Candidate.Two);
}
}
if (actualType == typeOne)
{
return(Candidate.One);
}
if (actualType == typeTwo)
{
return(Candidate.Two);
}
return(Candidate.Equivalent);
}
/// <summary>
/// Allocate a register for the given type.
/// </summary>
protected override RegisterSpec Allocate(TypeReference type, bool forceObject, RCategory category, object parameter)
{
var isWide = !forceObject && type.IsWide();
if (isWide)
{
var pair = body.AllocateWideRegister(category);
switch (category)
{
case RCategory.Temp:
return(new RegisterSpec(pair.Item1, pair.Item2, type));
case RCategory.Variable:
case RCategory.VariablePreventOptimization:
case RCategory.TempVariable:
return(new VariableRegisterSpec(pair.Item1, pair.Item2, type, (AstVariable)parameter));
case RCategory.Argument:
return(new ArgumentRegisterSpec(pair.Item1, pair.Item2, type, ParameterWrapper.Wrap(parameter)));
default:
throw new ArgumentException("Unknown category " + category);
}
}
var isPrimitive = !forceObject && (type is PrimitiveType);
var register = body.AllocateRegister(category, isPrimitive ? RType.Value : RType.Object);
switch (category)
{
case RCategory.Temp:
return(new RegisterSpec(register, null, type));
case RCategory.Variable:
case RCategory.VariablePreventOptimization:
case RCategory.TempVariable:
return(new VariableRegisterSpec(register, null, type, (AstVariable)parameter));
case RCategory.Argument:
return(new ArgumentRegisterSpec(register, null, type, ParameterWrapper.Wrap(parameter)));
default:
throw new ArgumentException("Unknown category " + category);
}
}
public static void Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("No arguments were passed.");
Console.WriteLine("Please pass the path to the file or a directory");
return;
}
String path = args[0];
String htmlCode = "<!DOCTYPE html>\r\n<html>\r\n\r\n<head>\r\n\r\n <!-- BOOTSTRAP 3 -->\r\n <link rel=\"stylesheet\" media=\"screen\" href=\"https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.5/css/bootstrap.min.css\">\r\n\r\n <!-- OUR CSS -->\r\n <link rel=\"stylesheet\" href=\"css/styles.css\">\r\n <link rel=\"stylesheet\" href=\"css/responsive.css\">\r\n <link rel=\"stylesheet\" href=\"css/custom.css\">\r\n\r\n <title>Class Details</title>\r\n</head>\r\n\r\n<body>\r\n\r\n <!--**************************************************************************************************\r\n HEADER\r\n **************************************************************************************************-->\r\n <nav class=\"navbar navbar-default\" role=\"navigation\">\r\n <div class=\"navbar-header\">\r\n <button type=\"button\" class=\"navbar-toggle\" data-toggle=\"collapse\" data-target=\".navbar-ex1-collapse\">\r\n\t\t\t<span class=\"sr-only\">Toggle navigation</span>\r\n\t\t\t<span class=\"icon-bar\"></span>\r\n\t\t\t<span class=\"icon-bar\"></span>\r\n\t\t\t<span class=\"icon-bar\"></span>\r\n\t\t</button>\r\n </div>\r\n\r\n <div class=\"collapse navbar-collapse navbar-ex1-collapse\">\r\n <ul class=\"nav navbar-nav\">\r\n <li><a href=\"#\">Overview</a></li>\r\n <li><a href=\"#\">Structures</a></li>\r\n <li><a href=\"#\">Classes</a></li>\r\n <li><a href=\"#\">Files</a></li>\r\n <li><a href=\"#\">Tree</a></li>\r\n </ul>\r\n </div>\r\n <!-- /.navbar-collapse -->\r\n </nav>\r\n \r\n <!-- MAIN CONTAINER -->\r\n <div class=\"container main-container\">";
htmlCode += ClassWebPage.generateClassName("LinkedList");
ClassWrapper[] classWrappers = new ClassWrapper[5];
for (var i = 0; i < 5; i++)
{
classWrappers[i] = new ClassWrapper("LinkedList", "", null, null);
}
htmlCode += ClassWebPage.generateImplementedClasses(classWrappers);
ParameterWrapper[] parameters = new ParameterWrapper[2];
for (var i = 0; i < parameters.Length; i++)
{
parameters[i] = new ParameterWrapper("start", "struct Node*");
}
htmlCode += ClassWebPage.generateFields(parameters);
ConstructorWrapper[] constructors = new ConstructorWrapper[2];
constructors[0] = new ConstructorWrapper("LinkedList", "", "", new ParameterWrapper[0]);
constructors[1] = new ConstructorWrapper("LinkedList", "", "", parameters);
htmlCode += ClassWebPage.generateConstructors(constructors);
MethodWrapper[] methods = new MethodWrapper[10];
for (var i = 0; i < methods.Length; i++)
{
methods[i] = new MethodWrapper("traverse", "Traverses the given LinkedList", "", parameters, "void");
}
htmlCode += ClassWebPage.generateMethods(methods);
htmlCode += "</div><!--.main-container-->\r\n\r\n\r\n\r\n <!-- JQUERY SCRIPT -->\r\n <script src=\"https://cdnjs.cloudflare.com/ajax/libs/jquery/1.11.3/jquery.min.js\"></script>\r\n <!-- BOOTSTRAP SCRIPT -->\r\n <script src=\"https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.5/js/bootstrap.min.js\"></script>\r\n <!-- OUR SCRIPT -->\r\n <script src=\"js/script.js\"></script>\r\n</body>\r\n\r\n</html>\r\n";
File.WriteAllText("/Users/gauravpunjabi/Desktop/index.html", htmlCode);
}
public override void save()
{
if (this._wrappedOperation == null)
{
this._wrappedOperation = this._factory._modelFactory.createNewElement <Operation>(this._owner._wrappedClass, this._name);
this._wrappedOperation.setStereotype(getStereotype());
}
if (this._wrappedOperation != null)
{
this._wrappedOperation.save();
this.isOverridden = this.isOverridden;
this.isRenamed = this.isRenamed;
//get the corresponding columns from this table
this.involvedColumns = getCorrespondingColumns();
if (this._wrappedOperation != null)
{
//first remove all existing parameters
this._wrappedOperation.ownedParameters = new HashSet <UML.Classes.Kernel.Parameter>();
uint parameterPosition = 0;
foreach (var column in _involvedColumns)
{
{
ParameterWrapper parameter = this._wrappedOperation.model.factory.createNewElement <Parameter>(this._wrappedOperation, column.name) as ParameterWrapper;
parameter.type = ((Column)column)._wrappedattribute.type;
parameter.position = parameterPosition;
//TODO: this would be nicer if we could keep the parameters in memory and not save them directly
parameter.save();
parameterPosition++;
}
}
}
}
//set all attributes to static
foreach (Column involvedColumn in this.involvedColumns)
{
if (involvedColumn._wrappedattribute != null &&
!involvedColumn._wrappedattribute.isStatic)
{
involvedColumn._wrappedattribute.isStatic = true;
involvedColumn._wrappedattribute.save();
}
}
}
protected override void DeserializeCore(XmlElement nodeElement, SaveContext context)
{
base.DeserializeCore(nodeElement, context);
var colorNode = nodeElement.ChildNodes.Cast <XmlNode>().FirstOrDefault(x => x.Name == "paramWrapper");
if (colorNode == null)
{
return;
}
var deserialized = DeserializeValue(colorNode.InnerText);
if (deserialized.Name == "None" && deserialized.BipName == "None")
{
return;
}
SelectedItem = deserialized;
}
public ComplectTypeWindow(ParameterGroup parameterGroup)
{
ParameterComplectType = new ParameterWrapper(new Parameter {
ParameterGroup = parameterGroup
});
OkCommand = new DelegateCommand(
() =>
{
IsOk = true;
this.Close();
},
() => ParameterComplectType.IsValid);
ParameterComplectType.PropertyChanged += (sender, args) => ((DelegateCommand)OkCommand).RaiseCanExecuteChanged();
InitializeComponent();
this.DataContext = this;
}
public override Candidate SelectBestConversionFor(DynamicMetaObject arg, ParameterWrapper candidateOne, ParameterWrapper candidateTwo, NarrowingLevel level)
{
Candidate basePreferred = base.SelectBestConversionFor(arg, candidateOne, candidateTwo, level);
if (basePreferred == Candidate.One || basePreferred == Candidate.Two)
{
return(basePreferred);
}
if (Converter.IsNumeric(arg.LimitType))
{
if (Converter.IsFloatingPoint(arg.LimitType))
{
if (Converter.IsFloatingPoint(candidateOne.Type))
{
if (!Converter.IsFloatingPoint(candidateTwo.Type))
{
return(Candidate.One);
}
}
else if (Converter.IsFloatingPoint(candidateTwo.Type))
{
return(Candidate.Two);
}
}
else // arg is integer
{
if (Converter.IsInteger(candidateOne.Type))
{
if (!Converter.IsInteger(candidateTwo.Type))
{
return(Candidate.One);
}
}
else if (Converter.IsInteger(candidateTwo.Type))
{
return(Candidate.Two);
}
}
}
return(basePreferred);
}
public override bool CanConvertFrom(Type/*!*/ fromType, ParameterWrapper/*!*/ toParameter, NarrowingLevel level) {
Type toType = toParameter.Type;
if (base.CanConvertFrom(fromType, toParameter, level)) {
return true;
}
// blocks:
if (fromType == typeof(MissingBlockParam)) {
return toType == typeof(BlockParam) && !toParameter.ProhibitNull;
}
if (fromType == typeof(BlockParam) && toType == typeof(MissingBlockParam)) {
return true;
}
// protocol conversions:
if (toParameter.ParameterInfo != null && toParameter.ParameterInfo.IsDefined(typeof(DefaultProtocolAttribute), false)) {
// any type is potentially convertible, except for nil if [NotNull] is used:
return fromType != typeof(DynamicNull) || !toParameter.ProhibitNull;
}
return false;
}
public override Candidate SelectBestConversionFor(DynamicMetaObject /*!*/ arg, ParameterWrapper /*!*/ candidateOne,
ParameterWrapper /*!*/ candidateTwo, NarrowingLevel level)
{
Type typeOne = candidateOne.Type;
Type typeTwo = candidateTwo.Type;
Type actualType = arg.GetLimitType();
if (actualType == typeof(DynamicNull))
{
// if nil is passed as a block argument prefers BlockParam over a missing block:
if (typeOne == typeof(BlockParam) && typeTwo == typeof(MissingBlockParam))
{
Debug.Assert(!candidateOne.ProhibitNull);
return(Candidate.One);
}
if (typeOne == typeof(MissingBlockParam) && typeTwo == typeof(BlockParam))
{
Debug.Assert(!candidateTwo.ProhibitNull);
return(Candidate.Two);
}
}
else
{
if (typeOne == actualType)
{
if (typeTwo == actualType)
{
// prefer non-nullable reference type over nullable:
if (!actualType.IsValueType)
{
if (candidateOne.ProhibitNull)
{
return(Candidate.One);
}
else if (candidateTwo.ProhibitNull)
{
return(Candidate.Two);
}
}
}
else
{
return(Candidate.One);
}
}
else if (typeTwo == actualType)
{
return(Candidate.Two);
}
}
// prefer integer type over enum:
if (typeOne.IsEnum && Enum.GetUnderlyingType(typeOne) == typeTwo)
{
return(Candidate.Two);
}
if (typeTwo.IsEnum && Enum.GetUnderlyingType(typeTwo) == typeOne)
{
return(Candidate.One);
}
return(base.SelectBestConversionFor(arg, candidateOne, candidateTwo, level));
}
public HttpParamers GetHttpParamers()
{
HttpParamers paramers = ParameterWrapper.WrapContract(this.quickContract);
return(paramers);
}
public override bool CanConvertFrom(ParameterWrapper /*!*/ fromParameter, ParameterWrapper /*!*/ toParameter)
{
return(Converter.CanConvertFrom(null, fromParameter.Type, toParameter.Type, toParameter.ProhibitNull, NarrowingLevel.None, false, false).IsConvertible);
}
/// <summary>
/// Returns true if fromArg of type fromType can be assigned to toParameter with a conversion on given narrowing level.
/// </summary>
public override bool CanConvertFrom(Type /*!*/ fromType, DynamicMetaObject fromArg, ParameterWrapper /*!*/ toParameter, NarrowingLevel level)
{
var result = Converter.CanConvertFrom(fromArg, fromType, toParameter.Type, toParameter.ProhibitNull, level,
HasExplicitProtocolConversion(toParameter), _implicitProtocolConversions
);
if (result.Assumption != null)
{
if (_argumentAssumptions == null)
{
_argumentAssumptions = new List <Key <int, NarrowingLevel, Ast> >();
}
if (_argumentAssumptions.FindIndex((k) => k.First == toParameter.ParameterInfo.Position && k.Second == level) < 0)
{
_argumentAssumptions.Add(Key.Create(toParameter.ParameterInfo.Position, level, result.Assumption));
}
}
return(result.IsConvertible);
}
/// <summary>
/// Returns true if fromArg of type fromType can be assigned to toParameter with a conversion on given narrowing level.
/// </summary>
public override bool CanConvertFrom(Type /*!*/ fromType, DynamicMetaObject fromArg, ParameterWrapper /*!*/ toParameter, NarrowingLevel level)
{
return(Converter.CanConvertFrom(fromArg, fromType, toParameter.Type, toParameter.ProhibitNull, level,
HasExplicitProtocolConversion(toParameter), _implicitProtocolConversions
));
}
public override Candidate SelectBestConversionFor(DynamicMetaObject arg, ParameterWrapper candidateOne, ParameterWrapper candidateTwo, NarrowingLevel level)
{
Candidate basePreferred = base.SelectBestConversionFor(arg, candidateOne, candidateTwo, level);
if (basePreferred == Candidate.One || basePreferred == Candidate.Two)
{
return(basePreferred);
}
// Work around the choice made in Converter.PreferConvert
// This cannot be done using NarrowingLevel rules because it would confuse rules for selecting custom operators
if (level >= PythonNarrowing.IndexOperator && Converter.IsPythonBigInt(arg.LimitType))
{
TypeCode c1tc = candidateOne.Type.GetTypeCode();
TypeCode c2tc = candidateTwo.Type.GetTypeCode();
if (c1tc is TypeCode.UInt32 && c2tc is TypeCode.Int32)
{
return(Candidate.Two);
}
if (c1tc is TypeCode.Int32 && c2tc is TypeCode.UInt32)
{
return(Candidate.One);
}
if (c1tc is TypeCode.UInt64 && c2tc is TypeCode.Int64)
{
return(Candidate.Two);
}
if (c1tc is TypeCode.Int64 && c2tc is TypeCode.UInt64)
{
return(Candidate.One);
}
}
// This block codifies the following set of rules for Python numerics (i.e. numeric types and any derived types):
// 1. Prefer the parameter that is of the matching kind to the argument type (i.e. floating-point to floating-point, or integer to integer).
// 2. If both parameters are of the matching kind, break the tie by prefering the one that is wider, if any (so the chance of overflow is lower).
// "Wider" here means being able to represent all values of the narrower type; e.g. in this sense UInt64 is not wider than SByte.
// There are the following exceptions to these rules:
// * Rule 1 is not applied to user-defined subtypes (i.e. subclasses of Extensible<T>). This is to allow such types to bind to parameters
// of type object or an interface on Extensible<T> (rule from the DLR). It is because a user-defined type may have user-defined operators
// that may need to be inspected by the overload and provide additional functionality above a simple numeric value.
// * Rule 2 is not applied on narrowing level None, so in a case of a widening cast or a perfect type match, the most efficient (narrowest)
// type is selected (rule from the DLR).
// * If one of the parameters is Boolean and the other is numeric, the Boolean parameter is treated as a 1-bit-wide numeric (thus becomes a case for Rule 2).
// This makes the preference for numeric types over Boolean consistent with the one encoded using narrowing levels and conversion sequence.
// TODO: Increase test coverage for cases involving Complex, Decimal, Half
if (Converter.IsPythonNumeric(arg.LimitType))
{
if (Converter.IsPythonFloatingPoint(arg.LimitType))
{
if (Converter.IsFloatingPoint(candidateOne.Type))
{
if (!Converter.IsFloatingPoint(candidateTwo.Type))
{
if (!Converter.IsExtensibleNumeric(arg.LimitType))
{
return(Candidate.One);
}
}
else if (level > PythonNarrowing.None) // both params are floating point
{
Candidate preferred = SelectWiderNumericType(candidateOne.Type, candidateTwo.Type);
if (preferred != Candidate.Ambiguous)
{
return(preferred);
}
}
}
else if (Converter.IsFloatingPoint(candidateTwo.Type))
{
if (!Converter.IsExtensibleNumeric(arg.LimitType))
{
return(Candidate.Two);
}
}
}
else // arg is integer
{
if (Converter.IsInteger(candidateOne.Type))
{
if (!Converter.IsInteger(candidateTwo.Type))
{
if (!Converter.IsExtensibleNumeric(arg.LimitType) || (Converter.IsBoolean(candidateTwo.Type) && level > PythonNarrowing.None))
{
return(Candidate.One);
}
}
else if (level > PythonNarrowing.None) // both params are integer
{
Candidate preferred = SelectWiderNumericType(candidateOne.Type, candidateTwo.Type);
if (preferred != Candidate.Ambiguous)
{
return(preferred);
}
}
}
else if (Converter.IsInteger(candidateTwo.Type))
{
if (!Converter.IsExtensibleNumeric(arg.LimitType) || (Converter.IsBoolean(candidateOne.Type) && level > PythonNarrowing.None))
{
return(Candidate.Two);
}
}
}
}
return(basePreferred);
}
public override bool CanConvertFrom(Type fromType, DynamicMetaObject fromArg, ParameterWrapper toParameter, NarrowingLevel level)
{
if ((fromType == typeof(List) || fromType.IsSubclassOf(typeof(List))))
{
if (toParameter.Type.IsGenericType() &&
toParameter.Type.GetGenericTypeDefinition() == typeof(IList <>) &&
(toParameter.ParameterInfo.IsDefined(typeof(BytesConversionAttribute), false) ||
toParameter.ParameterInfo.IsDefined(typeof(BytesConversionNoStringAttribute), false)))
{
return(false);
}
}
else if (fromType == typeof(string))
{
if (toParameter.Type == typeof(IList <byte>) &&
!Binder.Context.PythonOptions.Python30 &&
toParameter.ParameterInfo.IsDefined(typeof(BytesConversionAttribute), false))
{
// string -> byte array, we allow this in Python 2.6
return(true);
}
}
else if (fromType == typeof(Bytes))
{
if (toParameter.Type == typeof(string) &&
!Binder.Context.PythonOptions.Python30 &&
toParameter.ParameterInfo.IsDefined(typeof(BytesConversionAttribute), false))
{
return(true);
}
}
return(base.CanConvertFrom(fromType, fromArg, toParameter, level));
}
public override bool CanConvertFrom(Type fromType, DynamicMetaObject fromArg, ParameterWrapper toParameter, NarrowingLevel level)
{
if ((fromType == typeof(PythonList) || fromType.IsSubclassOf(typeof(PythonList))))
{
if (toParameter.Type.IsGenericType() &&
toParameter.Type.GetGenericTypeDefinition() == typeof(IList <>) &&
toParameter.ParameterInfo.IsDefined(typeof(BytesConversionAttribute), false))
{
return(false);
}
}
return(base.CanConvertFrom(fromType, fromArg, toParameter, level));
}
private bool IsBytesLikeParameter(ParameterWrapper parameter)
{
return(parameter.ParameterInfo?.IsDefined(typeof(BytesLikeAttribute), inherit: false) ?? false);
}
public override bool CanConvertFrom(Type fromType, DynamicMetaObject fromArg, ParameterWrapper toParameter, NarrowingLevel level)
{
Type toType = toParameter.Type;
if (IsBytesLikeParameter(toParameter))
{
if ((fromType == typeof(PythonList) || fromType.IsSubclassOf(typeof(PythonList))))
{
if (toType.IsGenericType &&
toType.GetGenericTypeDefinition() == typeof(IList <>))
{
return(false);
}
}
if (typeof(IBufferProtocol).IsAssignableFrom(fromType))
{
if (toParameter.Type == typeof(IList <byte>) || toParameter.Type == typeof(IReadOnlyList <byte>))
{
return(true);
}
}
}
if (fromType.IsGenericType &&
fromType.GetGenericTypeDefinition() == typeof(Memory <>) &&
toType.IsGenericType &&
toType.GetGenericTypeDefinition() == typeof(ReadOnlyMemory <>) &&
fromType.GetGenericArguments()[0] == toType.GetGenericArguments()[0])
{
return(true);
}
if (toType == typeof(IBufferProtocol))
{
if (fromType == typeof(Memory <byte>) ||
fromType == typeof(ReadOnlyMemory <byte>) ||
fromType == typeof(byte[]) ||
fromType == typeof(ArraySegment <byte>))
{
return(true);
}
}
if (fromType == typeof(int) && toType.IsAssignableFrom(typeof(BigInteger)))
{
return(true); // PEP 237: int/long unification (GH #52)
}
return(base.CanConvertFrom(fromType, fromArg, toParameter, level));
}
internal ParameterViewModel(ParameterWrapper wrapper)
{
Wrapper = wrapper;
}
private static void AddLinkedValueRowToDataGrid(DataGridView dgObj, GridColumnTemplate gct,
ParameterWrapper vdo)
{
var newRow = new DataGridViewRow();
Enum unitToUse = null;
var varUnitDict =
(Dictionary <string, Enum>)QraStateContainer.Instance.Parameters["VarUnitDict"];
varUnitDict.TryGetValue(vdo.Key, out unitToUse);
unitToUse = unitToUse ?? vdo.Unit;
string unitDisplayName = null;
if (unitToUse is UnitlessUnit)
{
var uu = (UnitlessUnit)unitToUse;
if (uu == UnitlessUnit.Unitless)
{
unitDisplayName = "...";
}
}
var valueObj = QraStateContainer.Instance.GetStateDefinedValueObject(vdo.Key);
var values = valueObj.GetValue(unitToUse);
if (gct == null && values.Length == 1)
{
if (unitToUse is UnitlessUnit || unitDisplayName != null)
{
newRow.CreateCells(dgObj, vdo.VariableDisplayName, Parsing.DoubleToString(values[0]),
unitDisplayName);
newRow.Cells[0].ReadOnly = true;
newRow.Cells[0].Tag = vdo.Key;
newRow.Cells[2].ReadOnly = true;
}
else
{
var unitType = unitToUse.GetType();
var possibleValues = unitType.GetEnumValues();
var cbCell = new DataGridViewComboBoxCell();
cbCell.DataSource = possibleValues;
cbCell.ValueType = unitType;
newRow.Cells.Add(new DataGridViewTextBoxCell());
newRow.Cells.Add(new DataGridViewTextBoxCell());
newRow.Cells.Add(cbCell);
newRow.Cells[0].Value = vdo.VariableDisplayName;
newRow.Cells[0].Tag = vdo.Key;
newRow.Cells[1].Value = Parsing.DoubleToString(values[0]);
newRow.Cells[2].Value = unitToUse;
newRow.Cells[0].ReadOnly = true;
}
}
else
{
if (gct == null && values.Length > 1)
{
throw new Exception("GridColumnTemplate is required when multiple values are specified.");
}
var cellValues = new string[gct.Headers.Length];
var indexIncrementor = 0;
if (gct.FirstColumnValues != null)
{
indexIncrementor += 1;
cellValues = new string[cellValues.Length + 1];
var optionalFirstColumnValueRowIndex = dgObj.Rows.Count - 1;
cellValues[0] = gct.FirstColumnValues[optionalFirstColumnValueRowIndex];
}
for (var cellIndex = 0; cellIndex < gct.Headers.Length; cellIndex++)
{
if (values.Length > cellIndex)
{
var svalue = values[cellIndex].ToString("F2", new CultureInfo("en-US"));
cellValues[cellIndex + indexIncrementor] = svalue;
}
}
newRow.CreateCells(dgObj, cellValues);
}
vdo.OriginalValues = values;
vdo.Unit = unitToUse;
newRow.Tag = vdo;
dgObj.Rows.Add(newRow);
}
public override Candidate SelectBestConversionFor(Type/*!*/ actualType, ParameterWrapper/*!*/ candidateOne, ParameterWrapper/*!*/ candidateTwo, NarrowingLevel level) {
Type typeOne = candidateOne.Type;
Type typeTwo = candidateTwo.Type;
if (actualType == typeof(DynamicNull)) {
// if nil is passed as a block argument prefer BlockParam over missing block;
if (typeOne == typeof(BlockParam) && typeTwo == typeof(MissingBlockParam)) {
return Candidate.One;
}
if (typeOne == typeof(MissingBlockParam) && typeTwo == typeof(BlockParam)) {
return Candidate.Two;
}
} else {
if (actualType == typeOne && candidateOne.ProhibitNull) {
return Candidate.One;
}
if (actualType == typeTwo && candidateTwo.ProhibitNull) {
return Candidate.Two;
}
}
if (actualType == typeOne) {
return Candidate.One;
}
if (actualType == typeTwo) {
return Candidate.Two;
}
return Candidate.Equivalent;
}
