Example #1
0
        public static Reference GetTypeReference(UTinyTypeCode typeCode)
        {
            var type = GetType(typeCode);

            if (null == type)
            {
                return(new Reference());
            }

            return((Reference)type);
        }
Example #2
0
        /// <summary>
        /// Returns the built in type based on the given typeCode
        /// </summary>
        public static UTinyType GetType(UTinyTypeCode typeCode)
        {
            switch (typeCode)
            {
            case UTinyTypeCode.Int8:
                return(Int8);

            case UTinyTypeCode.Int16:
                return(Int16);

            case UTinyTypeCode.Int32:
                return(Int32);

            case UTinyTypeCode.Int64:
                return(Int64);

            case UTinyTypeCode.UInt8:
                return(UInt8);

            case UTinyTypeCode.UInt16:
                return(UInt16);

            case UTinyTypeCode.UInt32:
                return(UInt32);

            case UTinyTypeCode.UInt64:
                return(UInt64);

            case UTinyTypeCode.Float32:
                return(Float32);

            case UTinyTypeCode.Float64:
                return(Float64);

            case UTinyTypeCode.Boolean:
                return(Boolean);

            case UTinyTypeCode.Char:
                return(Char);

            case UTinyTypeCode.String:
                return(String);

            case UTinyTypeCode.EntityReference:
                return(EntityReference);

            default:
                return(null);
            }
        }
        public UTinyType CreateType(UTinyId id, string name, UTinyTypeCode typeCode)
        {
            var type = new UTinyType(this, m_VersionStorage)
            {
                Id       = id,
                Name     = name,
                TypeCode = typeCode
            };

            m_VersionStorage.MarkAsChanged(type);

            Register(type);

            return(type);
        }
Example #4
0
        private static IProperty CreateDefaultValueProperty(UTinyTypeCode typeCode)
        {
            switch (typeCode)
            {
            case UTinyTypeCode.Unknown:
                return(null);

            case UTinyTypeCode.Int8:
                return(CreateSimpleDefaultValueProperty <sbyte>());

            case UTinyTypeCode.Int16:
                return(CreateSimpleDefaultValueProperty <short>());

            case UTinyTypeCode.Int32:
                return(CreateSimpleDefaultValueProperty <int>());

            case UTinyTypeCode.Int64:
                return(CreateSimpleDefaultValueProperty <long>());

            case UTinyTypeCode.UInt8:
                return(CreateSimpleDefaultValueProperty <byte>());

            case UTinyTypeCode.UInt16:
                return(CreateSimpleDefaultValueProperty <ushort>());

            case UTinyTypeCode.UInt32:
                return(CreateSimpleDefaultValueProperty <uint>());

            case UTinyTypeCode.UInt64:
                return(CreateSimpleDefaultValueProperty <ulong>());

            case UTinyTypeCode.Float32:
                return(CreateSimpleDefaultValueProperty <float>());

            case UTinyTypeCode.Float64:
                return(CreateSimpleDefaultValueProperty <double>());

            case UTinyTypeCode.Boolean:
                return(CreateSimpleDefaultValueProperty <bool>());

            case UTinyTypeCode.Char:
                return(CreateSimpleDefaultValueProperty <char>());

            case UTinyTypeCode.String:
                return(CreateSimpleDefaultValueProperty <string>());

            case UTinyTypeCode.Configuration:
            case UTinyTypeCode.Component:
            case UTinyTypeCode.Struct:
            case UTinyTypeCode.Enum:
                return(new ContainerProperty <UTinyType, UTinyObject>("DefaultValue",
                                                                      c => c.m_DefaultValue.Object,
                                                                      (c, v) =>
                {
                    if (null == v)
                    {
                        throw new NullReferenceException();
                    }

                    var obj = c.m_DefaultValue.Object;
                    obj?.CopyFrom(v);
                }));

            case UTinyTypeCode.EntityReference:
                return(CreateSimpleDefaultValueProperty <UTinyEntity.Reference>());

            case UTinyTypeCode.UnityObject:
                return(CreateSimpleDefaultValueProperty <UnityEngine.Object>());

            default:
                throw new ArgumentOutOfRangeException(nameof(typeCode), typeCode, null);
            }
        }