Пример #1
0
        public void Test_Implicit_String()
        {
            var obj  = new ConversionClass();
            var name = obj.DoSomeImplicit();

            Assert.AreEqual(name, "awais cheema");
        }
Пример #2
0
        private static ConversionClass ClassifyCLRArrayToInterfaceConversion(Type TargetInterface, Type SourceArrayType)
        {
            if (!Symbols.Implements(SourceArrayType, TargetInterface))
            {
                if (SourceArrayType.GetArrayRank() > 1)
                {
                    return(ConversionClass.Narrowing);
                }
                Type            elementType = SourceArrayType.GetElementType();
                ConversionClass none        = ConversionClass.None;
                if (TargetInterface.IsGenericType && !TargetInterface.IsGenericTypeDefinition)
                {
                    Type genericTypeDefinition = TargetInterface.GetGenericTypeDefinition();
                    if (((genericTypeDefinition == typeof(IList <>)) || (genericTypeDefinition == typeof(ICollection <>))) || (genericTypeDefinition == typeof(IEnumerable <>)))
                    {
                        none = ClassifyCLRConversionForArrayElementTypes(TargetInterface.GetGenericArguments()[0], elementType);
                    }
                }
                else
                {
#if NOT_PFX
                    none = ClassifyPredefinedCLRConversion(TargetInterface, typeof(IList <>).MakeGenericType(new Type[] { elementType }));
#else
                    throw new NotImplementedException();
#endif
                }
                if ((none != ConversionClass.Identity) && (none != ConversionClass.Widening))
                {
                    return(ConversionClass.Narrowing);
                }
            }
            return(ConversionClass.Widening);
        }
Пример #3
0
        private static bool NotEncompasses(Type Larger, Type Smaller)
        {
            ConversionClass class2 = ClassifyPredefinedConversion(Larger, Smaller);

            if ((class2 != ConversionClass.Narrowing) && (class2 != ConversionClass.Identity))
            {
                return(false);
            }
            return(true);
        }
Пример #4
0
        static void Main(string[] args)
        {
            int n = Convert.ToInt32(Console.ReadLine());

            int[] arr = Array.ConvertAll(Console.ReadLine().Split(' '), arrTemp => Convert.ToInt32(arrTemp));

            var myConversion = new ConversionClass();

            Console.WriteLine(myConversion.Reverse(arr.Take(n).ToArray()));
        }
Пример #5
0
        internal static ConversionClass ClassifyConversion(Type TargetType, Type SourceType, ref Symbols.Method OperatorMethod)
        {
            ConversionClass class3 = ClassifyPredefinedConversion(TargetType, SourceType);

            if ((((class3 != ConversionClass.None) || Symbols.IsInterface(SourceType)) || Symbols.IsInterface(TargetType)) || (!Symbols.IsClassOrValueType(SourceType) && !Symbols.IsClassOrValueType(TargetType)))
            {
                return(class3);
            }
            if (Symbols.IsIntrinsicType(SourceType) && Symbols.IsIntrinsicType(TargetType))
            {
                return(class3);
            }
            return(ClassifyUserDefinedConversion(TargetType, SourceType, ref OperatorMethod));
        }
        public async Task TypeConvertFrom()
        {
            const string value = "value";
            var          obj   = new ConversionClass();

            var           provider = new ReflectionEditorProvider();
            IObjectEditor editor   = await provider.GetObjectEditorAsync(obj);

            Assume.That(editor.Properties.Count, Is.EqualTo(1));

            await editor.SetValueAsync(editor.Properties.Single(), new ValueInfo <string> {
                Value  = value,
                Source = ValueSource.Local
            });

            Assert.That(obj.Property, Is.Not.Null);
            Assert.That(obj.Property.Property, Is.EqualTo(value));
        }
        public async Task TypeConverterTo()
        {
            const string value = "value";
            var          obj   = new ConversionClass {
                Property = new TestClass {
                    Property = value
                }
            };

            var           provider = new ReflectionEditorProvider();
            IObjectEditor editor   = await provider.GetObjectEditorAsync(obj);

            Assume.That(editor.Properties.Count, Is.EqualTo(1));

            ValueInfo <string> info = await editor.GetValueAsync <string> (editor.Properties.Single());

            Assert.That(info.Value, Is.EqualTo(value));
            Assert.That(info.Source, Is.EqualTo(ValueSource.Local));
        }
Пример #8
0
        internal static ConversionClass ClassifyUserDefinedConversion(Type TargetType, Type SourceType, ref Symbols.Method OperatorMethod)
        {
            ConversionClass class3 = 0;

            OperatorCaches.FixedList conversionCache = OperatorCaches.ConversionCache;
            lock (conversionCache)
            {
                if (OperatorCaches.UnconvertibleTypeCache.Lookup(TargetType) && OperatorCaches.UnconvertibleTypeCache.Lookup(SourceType))
                {
                    return(ConversionClass.None);
                }
                if (OperatorCaches.ConversionCache.Lookup(TargetType, SourceType, ref class3, ref OperatorMethod))
                {
                    return(class3);
                }
            }
            bool foundTargetTypeOperators = false;
            bool foundSourceTypeOperators = false;

            class3 = DoClassifyUserDefinedConversion(TargetType, SourceType, ref OperatorMethod, ref foundTargetTypeOperators, ref foundSourceTypeOperators);
            OperatorCaches.FixedList list2 = OperatorCaches.ConversionCache;
            lock (list2)
            {
                if (!foundTargetTypeOperators)
                {
                    OperatorCaches.UnconvertibleTypeCache.Insert(TargetType);
                }
                if (!foundSourceTypeOperators)
                {
                    OperatorCaches.UnconvertibleTypeCache.Insert(SourceType);
                }
                if (!foundTargetTypeOperators && !foundSourceTypeOperators)
                {
                    return(class3);
                }
                OperatorCaches.ConversionCache.Insert(TargetType, SourceType, class3, OperatorMethod);
            }
            return(class3);
        }
Пример #9
0
        static void Main(string[] args)
        {
            var conv = new ConversionClass(26);

            byte[] mas   = { 139, 52, 27, 139, 53, 27, 139, 54, 27, 139, 55, 27, 139, 56, 27, 139, 53, 27, 139, 56, 47, 139, 66, 47 };
            int    erros = 0;
            int    num   = 0;

            int res;

            do
            {
                res = conv.Conversion(mas, (uint)mas.Length, true, ref erros);

                if (res > 6)
                {
                    var resArray = conv.Read(0, 10);
                }
            }while (true);

            Console.WriteLine("Gotcha");
        }
Пример #10
0
	void Start ()
	{
		// Initialization of the main menu
		showListLanguage = false;
		hideMenuGUI = false;
		theScene = gameObject.GetComponent<BaseSceneClass>();
		dataBase = gameObject.GetComponent<ConversionClass>();

		// The setting of the GUI style for Pop up calls
		theListStyle.fontSize = ( BaseSceneClass.ourScreen.width / 100f < 16f ) ? 16 : ( int ) BaseSceneClass.ourScreen.width / 100;
		theListStyle.normal.textColor = Color.white;
		theListStyle.padding.left =
			theListStyle.padding.right =
				theListStyle.padding.top =
					theListStyle.padding.bottom = 4;

		if ( sample1 == null )
			theListStyle.onHover.background =
				theListStyle.hover.background = new Texture2D( 2, 2 );
		else
		{
			theListStyle.normal.background = sample1;
			theListStyle.onHover.background =
				theListStyle.hover.background = sample2;

		}
			
	}
 public TemperatureConversion()
 {
     InitializeComponent();
     _convTemp = new ConversionClass();
 }
        public static void Main(string[] args)
        {
            var conversionClass = new ConversionClass();

            conversionClass.ConvertFile(args);
        }