コード例 #1
0
 public override void Deserialize(Common.Serialization.IO.CompactReader reader)
 {
     _value      = reader.ReadObject() as IComparable;
     _order      = (SortOrder)reader.ReadByte();
     _type       = (FieldDataType)reader.ReadByte();
     _actualType = (TypeCode)reader.ReadInt32();
 }
コード例 #2
0
        public ActionResult AddField(string InfoName, FieldDataType DataType, int GroupID, TextType TextType = TextType.Libre, IntType IntType = IntType.Nombre, int?minValue = null, int?maxValue = null, string HaveMany = "no", string Required = "no", int Echelle = 5, string Defaults = null)
        {
            string def = "";

            if (Defaults != null)
            {
                var Listedefaults = Defaults.Trim().Split('\r', '\n');
                foreach (var item in Listedefaults)
                {
                    def += String.IsNullOrWhiteSpace(item) ? "" : ";" + item;
                }
            }
            var group  = _db.CustomGroups.Find(GroupID);
            var fields = group.CustomFields;

            if (fields.Where(g => g.InfoName == InfoName).FirstOrDefault() == null)
            {
                if (maxValue == null)
                {
                    maxValue = Echelle;
                }
                service.AddField(InfoName, DataType, group.GroupName, TextType, IntType, minValue, maxValue, HaveMany == "on", Required == "on", def);
                return(Json("OK"));
            }
            else
            {
                return(Json("NO"));
            }
        }
コード例 #3
0
ファイル: SqlGenerator.cs プロジェクト: ChrisNice89/VBA
        IValue ConvertToIValue(FieldDataType fieldDataType, object value)
        {
            if (DBNull.Value.Equals(value) || value == null)
            {
                return(new NullValue());
            }

            switch (fieldDataType)
            {
            case FieldDataType.Numeric:
                return(new NumericValue <double>((double)value));

            case FieldDataType.Text:
                return(new TextValue((string)value));

            case FieldDataType.DateTime:
                return(new DateTimeValue((DateTime)value));

            case FieldDataType.Boolean:
                return(new BooleanValue((bool)value));

            default:
                throw new NotSupportedException("Datatype for between not supported.");
            }
        }
コード例 #4
0
ファイル: SchemaInfo.cs プロジェクト: valery-shinkevich/sooda
        public object GetDefaultPrecommitValueForDataType(FieldDataType dataType)
        {
            if (PrecommitValues != null)
            {
                foreach (PrecommitValueInfo value in PrecommitValues)
                {
                    if (dataType == value.DataType)
                    {
                        return(value.Value);
                    }
                }
            }
            switch (DefaultPrecommitValues)
            {
            case DefaultPrecommitValues.None:
                return(null);

            case DefaultPrecommitValues.Zero:
                return(FieldHandlerFactory.GetFieldHandler(dataType).DefaultPrecommitValue());

            case DefaultPrecommitValues.Null:
                return(NullPrecommitValue);

            default:
                throw new NotImplementedException(DefaultPrecommitValues.ToString());
            }
        }
コード例 #5
0
ファイル: FieldNode.cs プロジェクト: Austin-Schaffer/Djounal
 public FieldNode(XmlNode xml)
 {
     this.intFieldId    = int.Parse(xml.Attributes["FieldId"].Value);
     this.strFieldName  = xml.Attributes["FieldName"].Value;
     this.dataType      = (FieldDataType)Enum.Parse(typeof(FieldDataType), xml.Attributes["DataType"].Value);
     this.boolIsEnabled = bool.Parse(xml.Attributes["IsEnabled"].Value);
 }
コード例 #6
0
        private static string GetBaseReadOperation(FieldDataType t)
        {
            switch (t)
            {
            case FieldDataType.FLOAT32: return("ReadSingle");

            case FieldDataType.INT8: return("ReadSByte");

            case FieldDataType.UINT8: return("ReadByte");

            case FieldDataType.INT16: return("ReadInt16");

            case FieldDataType.UINT16: return("ReadUInt16");

            case FieldDataType.INT32: return("ReadInt32");

            case FieldDataType.UINT32: return("ReadUInt32");

            case FieldDataType.INT64: return("ReadInt64");

            case FieldDataType.UINT64: return("ReadUInt64");

            case FieldDataType.CHAR: return("ReadChar");

            default:
                Console.WriteLine("ERROR: Unknown uavType: " + t);
                return("UNKNOWN_UAS_TYPE");
            }
        }
コード例 #7
0
ファイル: FieldNode.cs プロジェクト: Austin-Schaffer/Djounal
 public FieldNode(int _fieldId, string _fieldName, FieldDataType _dataType, bool _isEnabled = true)
 {
     this.intFieldId    = _fieldId;
     this.strFieldName  = _fieldName;
     this.dataType      = _dataType;
     this.boolIsEnabled = _isEnabled;
 }
コード例 #8
0
        //return true if value can be converted to FieldDataType
        public static bool CheckType(string value, FieldDataType fdt)
        {
            bool result = true;

            try
            {
                switch (fdt)
                {
                case FieldDataType.DATE:
                    DateTime.Parse(value);
                    break;

                case FieldDataType.FLOAT:
                    float.Parse(value);
                    break;

                case FieldDataType.INT:
                    int.Parse(value);
                    break;

                case FieldDataType.TEXT:
                    // nothing to check
                    break;

                default:
                    throw new Exception("FieldDataType invalid.");
                }
            }
            catch
            {
                result = false;
            }

            return(result);
        }
コード例 #9
0
ファイル: JSONType.cs プロジェクト: waqashaneef/NosDB
        public static IComparable Enforce(object value, out FieldDataType matchType, out TypeCode actualType)
        {
            matchType = GetJSONType(value, out actualType);
            switch (matchType)
            {
            case FieldDataType.Number:
                switch (actualType)
                {
                case TypeCode.Int16:
                case TypeCode.Int32:
                case TypeCode.Int64:
                case TypeCode.Byte:
                case TypeCode.SByte:
                case TypeCode.UInt16:
                case TypeCode.UInt32:
                case TypeCode.UInt64:
                    return(Convert.ToInt64(value));

                default:
                    return(Convert.ToDouble(value));
                }

            case FieldDataType.String:
                return(value.ToString());

            case FieldDataType.Bool:
                return((bool)value);

            default:
                return((IComparable)value);
            }
        }
コード例 #10
0
        /*
         * Throws ArgumentException if list isn't valid.
         */
        public RangeList(string rangeList, FieldDataType rangeListType)
        {
            try
            {
                _ranges        = new List <Range>();
                _rangeListType = rangeListType;
                _rangeListRaw  = rangeList;

                if (string.IsNullOrEmpty(rangeList) || rangeListType == FieldDataType.UNKNOWN)
                {
                    throw new ArgumentException("rangeList can't be empty or rangeListType invalid.");
                }

                string[] items = rangeList.Trim().Split(new char[] { ',' });

                foreach (string item in items)
                {
                    _ranges.Add(new Range(item, this));
                }
            }
            catch (Exception e)
            {
                _ranges        = null;
                _rangeListType = FieldDataType.UNKNOWN;
                _rangeListRaw  = null;
                throw new ArgumentException("An error ocurred while construction RangeList: " + e.Message);
            }
        }
コード例 #11
0
        /// <summary>
        /// Map from a Haestad.Domain FieldDataType to a .NET Type.
        /// </summary>
        static public Type TypeFromFieldDataType(FieldDataType type)
        {
            switch (type)
            {
            case FieldDataType.Boolean:
                return(typeof(bool));

            case FieldDataType.DateTime:
                return(typeof(DateTime));

            case FieldDataType.Integer:
            case FieldDataType.Referenced:
            case FieldDataType.Enumerated:
                return(typeof(int));

            case FieldDataType.Text:
            case FieldDataType.LongText:
                return(typeof(String));

            case FieldDataType.Real:
                return(typeof(double));

            //TODO 0 Review later for robustness.
            case FieldDataType.Collection:
                return(typeof(byte));

            default:
                Debug.Assert(false);
                return(null);
            }
        }
コード例 #12
0
        private static string GetBaseCSharpType(FieldDataType t)
        {
            switch (t)
            {
            case FieldDataType.FLOAT32: return("float");

            case FieldDataType.INT8: return("SByte");

            case FieldDataType.UINT8: return("byte");

            case FieldDataType.INT16: return("Int16");

            case FieldDataType.UINT16: return("UInt16");

            case FieldDataType.INT32: return("Int32");

            case FieldDataType.UINT32: return("UInt32");

            case FieldDataType.INT64: return("Int64");

            case FieldDataType.UINT64: return("UInt64");

            case FieldDataType.CHAR: return("char");

            default:
                return("!!!!");
            }
        }
コード例 #13
0
        /// <summary>
        /// Serialize an object using .NET's Binary formatter and returns it encoded into base64 string
        /// </summary>
        /// <param name="obj">Object to serialize</param>
        /// <param name="culture">Culture to use during the serialization</param>
        /// <returns>Base64 string</returns>
        static public String SerializeToString(FieldDataType fieldDataType, Object obj, CultureInfo culture)
        {
            if (obj == null)
            {
                return("");             // DO NOT LOCALIZE <ccla>
            }
            switch (fieldDataType)
            {
            case FieldDataType.Real:
                return(((Double)obj).ToString(culture.NumberFormat));

            case FieldDataType.DateTime:
                return(((DateTime)obj).ToString(culture));

            case FieldDataType.Boolean:
            case FieldDataType.Enumerated:
            case FieldDataType.Integer:
            case FieldDataType.Referenced:
            case FieldDataType.LongText:
            case FieldDataType.Text:
                return(obj.ToString());

            default:
                using (MemoryStream stream = new MemoryStream())
                {
                    BinaryWriter    bw        = new BinaryWriter(stream);
                    BinaryFormatter formatter = new BinaryFormatter();
                    formatter.Serialize(stream, obj);
                    return(Convert.ToBase64String(stream.GetBuffer()));
                }
            }
        }
コード例 #14
0
        public void AddField(string InfoName, FieldDataType DataType, string GroupName, TextType TextType = TextType.Libre, int?minValue = null, int?maxValue = null, bool HaveMany = false, bool Required = false)
        {
            CustomField cf = new CustomField
            {
                InfoName = InfoName,
                DataType = DataType,
                HaveMany = HaveMany,
                required = Required
            };

            switch (DataType)
            {
            case FieldDataType.String: { cf.TextType = TextType; break; };

            case FieldDataType.Int:
            case FieldDataType.Decimal:
            case FieldDataType.Double: { cf.Min = minValue; cf.Max = maxValue; break; };

            case FieldDataType.DateTime: {; break; };

            default: {; break; };
            }
            var group = _db.CustomGroups.Where(g => g.GroupName == GroupName).Single();

            group.CustomFields.Add(cf);
            _db.Entry(group).State = EntityState.Modified;
            _db.SaveChanges();
        }
コード例 #15
0
        /// <summary>
        /// Returns a default (zero) value for a FieldDataType.
        /// </summary>
        /// <param name="atype">FieldDataType to return a default value for.</param>
        /// <returns>Default value for the passed FieldDataType.</returns>
        static public Object DefaultValueFor(FieldDataType atype)
        {
            switch (atype)
            {
            case FieldDataType.Enumerated:
            case FieldDataType.Integer:
            case FieldDataType.Referenced:
                return(0);

            case FieldDataType.Real:
                return(0.0);

            case FieldDataType.Text:
            case FieldDataType.LongText:
                return(String.Empty);

            case FieldDataType.Boolean:
                return(false);

            case FieldDataType.DateTime:
                return(DateTime.Now);

            case FieldDataType.LongBinary:
            case FieldDataType.Collection:
                return(null);

            default:
                throw new IndexOutOfRangeException();
            }
        }
コード例 #16
0
        private IComparable PerformArithmeticOperation(IEvaluable evaluable, IJSONDocument document, ArithmeticOperation operation)
        {
            IJsonValue value1, value2;

            if (!Evaluate(out value1, document))
            {
                return(null);
            }
            if (!evaluable.Evaluate(out value2, document))
            {
                return(null);
            }

            TypeCode      actualType1, actualType2;
            FieldDataType fieldDataType1 = JSONType.GetJSONType(value1.Value, out actualType1);
            FieldDataType fieldDataType2 = JSONType.GetJSONType(value2.Value, out actualType2);

            if (fieldDataType1.CompareTo(fieldDataType2) != 0)
            {
                return(null);
            }

            return(Evaluator.PerformArithmeticOperation(value1, actualType1, value2, actualType2, operation,
                                                        fieldDataType1));
        }
コード例 #17
0
ファイル: ElfVariable.cs プロジェクト: DIVON/MCUHelper
        public virtual void LoadFromXml(XElement xml)
        {
            Name = XmlUtilits.GetFieldValue(xml, "Name", "ERROR");
            String datatypeStr = XmlUtilits.GetFieldValue(xml, "DataType", "ERROR");

            datatype = (FieldDataType)Enum.Parse(typeof(FieldDataType), datatypeStr);
        }
コード例 #18
0
 public Field(string dbFName, string clsFName, string formField, FieldType type, FieldDataType dataType)
 {
     this.clsFieldName  = clsFName;
     this.dbFieldName   = dbFName;
     this.formFieldName = formField;
     this.type          = type;
     this.dataType      = dataType;
 }
コード例 #19
0
 /// <summary>
 /// Initializes a new instance of the <see cref="T:Kamtro_Bot.Nodes.MessageFieldNode"/> class.
 /// </summary>
 /// <param name="name">The displayed name of the field.</param>
 /// <param name="page">The page that the field is on.</param>
 /// <param name="pos">The field's position on it's page.</param>
 /// <param name="value">The value of the field.</param>
 /// <param name="dataType">Data type of the field. Default is string.</param>
 public MessageFieldNode(string name, int page, int pos, string value = "[Enter Value]", FieldDataType dataType = FieldDataType.STR)
 {
     Name  = name;
     Page  = page;
     Pos   = pos;
     Value = value;
     Type  = dataType;
 }
コード例 #20
0
        public void GenerateBetweenSqlString_AddBetweenCondition(FieldDataType dataType, object value1, object value2, string expected)
        {
            _csb.AddBetweenCondition("Field1", dataType, value1, value2);

            var actual = _csb.ToString();

            Assert.AreEqual(expected, actual);
        }
コード例 #21
0
        public void GenerateSqlString_FieldAndValue(object fieldName, FieldDataType dataType, RelationalOperators relationalOperator, object value, string expected)
        {
            _csb.Add(fieldName, dataType, relationalOperator, value);

            var actual = _csb.ToString();

            Assert.AreEqual(expected, actual);
        }
コード例 #22
0
        public void SetData(byte[] data, FieldDataType type)
        {
            _opFlags  = _opFlags.SetBitAtIndex(LoadDataFromImageFlag, false);
            _opFlags  = _opFlags.SetBitAtIndex(LoadDataFromStateFlag, (data != null && data.Length > 0));
            _dataType = type;
            _module.FieldDataBlob[_rid - 1] = data;

            OnChanged();
        }
コード例 #23
0
        public void GenerateSqlString_DbNullValue(FieldDataType dataType, RelationalOperators relationalOperator)
        {
            _csb.Add("Field1", dataType, relationalOperator, System.DBNull.Value);
            _csb.Add("Field2", dataType, relationalOperator, System.DBNull.Value);

            var actual = _csb.ToString();

            Assert.AreEqual(string.Empty, actual);
        }
コード例 #24
0
ファイル: SoqlParser.cs プロジェクト: valery-shinkevich/sooda
        private SoqlLiteralValueModifiers ParseLiteralValueModifiers()
        {
            SoqlLiteralValueModifiers retVal = new SoqlLiteralValueModifiers();

            string        typeName     = tokenizer.EatKeyword();
            FieldDataType typeOverride = (FieldDataType)FieldDataType.Parse(typeof(FieldDataType), typeName);

            retVal.DataTypeOverride = typeOverride;
            return(retVal);
        }
コード例 #25
0
        public void GenerateSqlString_ConcatBetweenDbNullValue(FieldDataType dataType)
        {
            _csb.Add("Field1", FieldDataType.Text, RelationalOperators.Between, new object[] { System.DBNull.Value, "xyz" });
            _csb.Add("Field2", FieldDataType.Numeric, RelationalOperators.Between, new object[] { 133.45, System.DBNull.Value });
            _csb.Add("Field3", dataType, RelationalOperators.Between, new object[] { System.DBNull.Value, System.DBNull.Value });

            var actual = _csb.ToString();

            Assert.AreEqual("Field1 <= 'xyz' And Field2 >= 133.45", actual);
        }
コード例 #26
0
        public void GenerateBetweenSqlString_Values(FieldDataType dataType, object value1, object value2, string expected)
        {
            var betweenValues = new object[] { value1, value2 };

            _csb.Add("Field1", dataType, RelationalOperators.Between, betweenValues);

            var actual = _csb.ToString();

            Assert.AreEqual(expected, actual);
        }
コード例 #27
0
        public void GenerateSqlStringFieldAndValue_Between(object fieldName, FieldDataType fieldDataType, RelationalOperators relationalOperator, object value1, object value2, string expected)
        {
            object[] values = new[] { value1, value2 };

            _csb.Add(fieldName, fieldDataType, relationalOperator, values);

            var actual = _csb.ToString();

            Assert.AreEqual(expected, actual);
        }
コード例 #28
0
ファイル: FieldMappings.cs プロジェクト: membersuite/portal
    public static List <FieldDisplayType> GetDependentDisplayTypesFor(FieldDataType dataType)
    {
        List <FieldDisplayType> relatedDisplayTypes;

        if (!_dataMappingToDisplayCache.TryGetValue(dataType, out relatedDisplayTypes))
        {
            return(new List <FieldDisplayType>()); // emptty list
        }
        return(relatedDisplayTypes);
    }
コード例 #29
0
ファイル: BPlusIndex.cs プロジェクト: waqashaneef/NosDB
        protected virtual AttributeValue GetBound(FieldDataType type, Bound bound)
        {
            var boundary   = new BoundaryValueMask(type, bound);
            var enumerator = GetEnumerator(boundary);

            while (enumerator.MoveNext())
            {
                ;
            }
            return(boundary.State);
        }
コード例 #30
0
        public void GenerateBetweenSqlString_DbNullValue(FieldDataType dataType)
        {
            var betweenValues = new object[] { System.DBNull.Value, System.DBNull.Value };

            _csb.Add("Field1", dataType, RelationalOperators.Between, betweenValues);
            _csb.Add("Field2", dataType, RelationalOperators.Between, betweenValues);

            var actual = _csb.ToString();

            Assert.AreEqual(string.Empty, actual);
        }
コード例 #31
0
ファイル: ViewHelper.cs プロジェクト: Godoy/CMS
 public static IHtmlString EditFieldAttributes(TextContent data, string fieldName, FieldDataType dataType)
 {
     if (dataType == FieldDataType.Auto)
     {
         dataType = QueryFieldDataType(data, fieldName);
     }
     if (data == null || !Page_Context.Current.EnabledInlineEditing(EditingType.Content)
         || !Kooboo.CMS.Content.Services.ServiceFactory.WorkflowManager.AvailableToEditContent(data, Page_Context.Current.ControllerContext.HttpContext.User.Identity.Name))
     {
         return new HtmlString("");
     }
     return new HtmlString(string.Format("editType=\"field\" dataType=\"{0}\" schema=\"{1}\" folder=\"{2}\" uuid=\"{3}\" fieldName=\"{4}\"", dataType.ToString(), data.SchemaName, data.FolderName, data.UUID, fieldName));
 }
コード例 #32
0
ファイル: ViewHelper.cs プロジェクト: Godoy/CMS
 public static IHtmlString EditField(TextContent data, string fieldName, FieldDataType dataType)
 {
     if (dataType == FieldDataType.Auto)
     {
         dataType = QueryFieldDataType(data, fieldName);
     }
     if (data == null || !Page_Context.Current.EnabledInlineEditing(EditingType.Content)
         || !Kooboo.CMS.Content.Services.ServiceFactory.WorkflowManager.AvailableToEditContent(data, Page_Context.Current.ControllerContext.HttpContext.User.Identity.Name))
     {
         return new HtmlString(data[fieldName] == null ? "" : data[fieldName].ToString());
     }
     var format = "<var start=\"true\" editType=\"field\" dataType=\"{0}\" schema=\"{1}\" folder=\"{2}\" uuid=\"{3}\" fieldName=\"{4}\" style=\"display:none;\"></var>{5}<var end=\"true\" style=\"display:none;\"></var>";
     return new HtmlString(string.Format(format, dataType.ToString(), data.SchemaName, data.FolderName, data.UUID, fieldName, data[fieldName]));
 }
コード例 #33
0
ファイル: FieldInfo.cs プロジェクト: valery-shinkevich/sooda
 internal void Merge(FieldInfo merge)
 {
     this.DataType = merge.DataType;
     if (merge.Description != null)
         this.Description = (this.Description != null ? this.Description + "\n" : "") + merge.Description;
     if (merge.Size != -1)
         this.Size = merge.Size;
     if (merge.Precision != -1)
         this.Precision = merge.Size;
     if (merge.References != null)
         this.References = merge.References;
     if (merge.PrecommitValue != null)
         this.PrecommitValue = merge.PrecommitValue;
     this.IsPrimaryKey = merge.IsPrimaryKey;
     this.IsNullable = merge.IsNullable;
     this.ReadOnly = merge.ReadOnly;
     this.ForceTrigger = merge.ForceTrigger;
     this.DeleteAction = merge.DeleteAction;
     this.IsLabel = merge.IsLabel;
     this.PrefetchLevel = merge.PrefetchLevel;
     this.FindMethod = merge.FindMethod;
     this.FindListMethod = merge.FindListMethod;
     if (merge.dbcolumn != null)
         this.DBColumnName = merge.dbcolumn;
 }
コード例 #34
0
ファイル: FieldInfo.cs プロジェクト: valery-shinkevich/sooda
 internal void ResolveReferences(SchemaInfo schema)
 {
     if (References == null)
         return;
     ClassInfo ci = schema.FindClassByName(References);
     if (ci == null)
         throw new SoodaSchemaException("Class " + References + " not found.");
     DataType = ci.GetFirstPrimaryKeyField().DataType;
     ReferencedClass = ci;
 }
コード例 #35
0
ファイル: VnaFileTestItem.cs プロジェクト: BgRva/Blob1
 public static bool IsMatch(FieldDataType testTypeIndicator, Type actualType)
 {
     if (testTypeIndicator == FieldDataType.Int && actualType == typeof(int))
         return true;
     if (testTypeIndicator == FieldDataType.Float && actualType == typeof(Single))
         return true;
     if (testTypeIndicator == FieldDataType.Double && actualType == typeof(double))
         return true;
     if (testTypeIndicator == FieldDataType.DateTime && actualType == typeof(DateTime))
         return true;
     if (testTypeIndicator == FieldDataType.Bool && actualType == typeof(bool))
         return true;
     if (testTypeIndicator == FieldDataType.String && actualType == typeof(string))
         return true;
     return false;
 }
コード例 #36
0
ファイル: Field.cs プロジェクト: hanchao/DotSpatial
 /// <summary>
 /// Creates a new field with a specific name and using a simplified enumeration of possible types.
 /// </summary>
 /// <param name="inColumnName">the string column name.</param>
 /// <param name="type">The type enumeration that clarifies which basic data type to use.</param>
 public Field(string inColumnName, FieldDataType type)
     : base(inColumnName)
 {
     if (type == FieldDataType.Double) DataType = typeof(double);
     if (type == FieldDataType.Integer) DataType = typeof(int);
     if (type == FieldDataType.String) DataType = typeof(string);
 }
コード例 #37
0
ファイル: VnaFileTestItem.cs プロジェクト: BgRva/Blob1
 public static Type ToType(FieldDataType testTypeIndicator)
 {
     switch (testTypeIndicator)
     {
         case FieldDataType.Int:
             return typeof (int);
         case FieldDataType.Float:
             return typeof (float);
         case FieldDataType.Double:
             return typeof (double);
         case FieldDataType.Bool:
             return typeof (bool);
         case FieldDataType.DateTime:
             return typeof (DateTime);
         default:
             return typeof (string);
     }
 }
コード例 #38
0
ファイル: VnaFileTestItem.cs プロジェクト: BgRva/Blob1
        public FieldDataType[] ToFieldDataTypeArray(string input)
        {
            if (string.IsNullOrWhiteSpace(input))
                return null;

            var fields = input.Split(',');
            var result = new FieldDataType[fields.Length];
            for (int i = 0; i < fields.Length; i++)
            {
                var field = fields[i];
                result[i] = (FieldDataType)int.Parse(field);
            }
            return result;
        }
コード例 #39
0
ファイル: SchemaInfo.cs プロジェクト: valery-shinkevich/sooda
 public object GetDefaultPrecommitValueForDataType(FieldDataType dataType)
 {
     if (PrecommitValues != null)
     {
         foreach (PrecommitValueInfo value in PrecommitValues)
             if (dataType == value.DataType)
                 return value.Value;
     }
     switch (DefaultPrecommitValues)
     {
         case DefaultPrecommitValues.None:
             return null;
         case DefaultPrecommitValues.Zero:
             return FieldHandlerFactory.GetFieldHandler(dataType).DefaultPrecommitValue();
         case DefaultPrecommitValues.Null:
             return NullPrecommitValue;
         default:
             throw new NotImplementedException(DefaultPrecommitValues.ToString());
     }
 }
コード例 #40
0
ファイル: CSharpGenerator.cs プロジェクト: haakoo/mavlink.net
        private static string GetBaseReadOperation(FieldDataType t)
        {
            switch (t)
            {
                case FieldDataType.FLOAT32: return "ReadSingle";
                case FieldDataType.INT8: return "ReadSByte";
                case FieldDataType.UINT8: return "ReadByte";
                case FieldDataType.INT16: return "ReadInt16";
                case FieldDataType.UINT16: return "ReadUInt16";
                case FieldDataType.INT32: return "ReadInt32";
                case FieldDataType.UINT32: return "ReadUInt32";
                case FieldDataType.INT64: return "ReadInt64";
                case FieldDataType.UINT64: return "ReadUInt64";
                case FieldDataType.CHAR: return "ReadChar";

                default:
                    Console.WriteLine("ERROR: Unknown uavType: " + t);
                    return "UNKNOWN_UAS_TYPE";
            }
        }
コード例 #41
0
ファイル: CSharpGenerator.cs プロジェクト: haakoo/mavlink.net
 private static string GetBaseCSharpType(FieldDataType t)
 {
     switch (t)
     {
         case FieldDataType.FLOAT32: return "float";
         case FieldDataType.INT8: return "SByte";
         case FieldDataType.UINT8: return "byte";
         case FieldDataType.INT16: return "Int16";
         case FieldDataType.UINT16: return "UInt16";
         case FieldDataType.INT32: return "Int32";
         case FieldDataType.UINT32: return "UInt32";
         case FieldDataType.INT64: return "Int64";
         case FieldDataType.UINT64: return "UInt64";
         case FieldDataType.CHAR: return "char";
         default:
             return "!!!!";
     }
 }
コード例 #42
0
ファイル: Sheet.cs プロジェクト: SyncZone/IndieAPI
 internal void AddField(FieldDataType type, String name)
 {
     _fields[_nextFieldIdx] = new FieldInfo() { type = type, name = name };
     ++_nextFieldIdx;
 }
コード例 #43
0
 public static SoodaFieldHandler GetFieldHandler(FieldDataType type)
 {
     return _nullableHandlers[(int) type];
 }
コード例 #44
0
 public static SoodaFieldHandler GetFieldHandler(FieldDataType type, bool nullable)
 {
     return (nullable ? _nullableHandlers : _notNullHandlers)[(int) type];
 }