public DataTypeValidator(DataType dataType, object data)
        {
            m_dataType = dataType;
            m_data = data;

            SetActualDataType();
        }

        public PyBuildValueFormatParser(
            Program program,
            Address addrInstr,
            string format,
            IServiceProvider services)
        {
            this.ArgumentTypes = new List<DataType>();
            this.format = format;
            var platform = program.Platform;
            this.pointerSize = platform.PointerType.Size;

            var wordSize = platform.Architecture.WordWidth.Size;
            var longSize = platform.GetByteSizeFromCBasicType(
                CBasicType.Long);
            var longLongSize = platform.GetByteSizeFromCBasicType(
                CBasicType.LongLong);
            var doubleSize = platform.GetByteSizeFromCBasicType(
                CBasicType.Double);

            dtInt = Integer(wordSize);
            dtUInt = UInteger(wordSize);
            dtLong = Integer(longSize);
            dtULong = UInteger(longSize);
            dtLongLong = Integer(longLongSize);
            dtULongLong = UInteger(longLongSize);
            dtDouble = Real(doubleSize);
            ptrChar = Ptr(PrimitiveType.Char);
            ptrVoid = Ptr(VoidType.Instance);

            dtPySize = UInteger(pointerSize);
            ptrPyObject = Ptr(Ref("PyObject"));
            ptrPyUnicode = Ptr(Ref("Py_UNICODE"));
            ptrPyComplex = Ptr(Ref("Py_complex"));
            ptrPyConverter = Ptr(new CodeType());
        }

 public DataTypeGraphModel(IViewModelDependencies appCtx, IZetboxContext dataCtx, DiagramViewModel parent,
     DataType obj)
     : base(appCtx, dataCtx, parent, obj)
 {
     this._diagMdl = parent;
     this.DataType = obj;
 }

        public IEnumerable<string> Unify(DataType a, DataType b)
        {
            a = Normalize(a);
            b = Normalize(b);

            if (a is TypeVariable)
            {
                var variableA = (TypeVariable)a;

                if (b.Contains(variableA))
                {
                    if (a != b)
                        return Error(a, b);

                    return success;
                }

                substitutions[variableA] = b;
                return success;
            }

            if (b is TypeVariable)
                return Unify(b, a);

            if (a.Name != b.Name)
                return Error(a, b);

            if (a.GenericArguments.Count() != b.GenericArguments.Count())
                return Error(a, b);

            return PairwiseUnify(a.GenericArguments, b.GenericArguments);
        }

        public DataTypeAttribute(DataType dataType)
        {
            this.DataType = dataType;
            this.InitializeDefaultErrorMessage();
            switch (this.DataType)
            {
                case DataType.Boolean:
                    this.UsesCustomValidation = true;
                    break;

                case DataType.Alphabetic:
                    this.UsesRegularExpression = true;
                    this.CurrentRegularExpression = AlphabeticMatcher.ToString();
                    break;

                case DataType.AlphaNumeric:
                    this.UsesRegularExpression = true;
                    this.CurrentRegularExpression = AlphaNumericMatcher.ToString();
                    break;

                case DataType.PhoneNumber:
                    this.UsesRegularExpression = true;
                    this.CurrentRegularExpression = PhoneNumberMatcher.ToString();
                    break;

                case DataType.ZipCode:
                    this.UsesRegularExpression = true;
                    this.CurrentRegularExpression = ZipCodeMatcher.ToString();
                    break;

                case DataType.EmailAddress:
                    this.UsesRegularExpression = true;
                    this.CurrentRegularExpression = EmailMatcher.ToString();
                    break;

                case DataType.IpAddress:
                    this.UsesRegularExpression = true;
                    this.CurrentRegularExpression = IpAddressMatcher.ToString();
                    break;

                case DataType.Url:
                    this.UsesRegularExpression = true;
                    this.CurrentRegularExpression = UrlCodeMatcher.ToString();
                    break;

                case DataType.CreditCard:
                    this.UsesRegularExpression = true;
                    this.CurrentRegularExpression = CreditCardMatcher.ToString();
                    break;

                case DataType.CreditCardLuhn:
                    this.UsesCustomValidation = true;
                    break;

                case DataType.SocialSecurityNumber:
                    this.UsesRegularExpression = true;
                    this.CurrentRegularExpression = SocialSecurityMatcher.ToString();
                    break;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="DataTypeInfo" /> class.
        /// </summary>
        /// <param name="type">The type.</param>
        /// <param name="rules">The rules.</param>
        /// <exception cref="NotSupportedException"></exception>
        public DataTypeInfo(DataType type, IEnumerable<RuleMap> rules)
        {
            switch (type)
            {
                case DataType.Text:
                    Description = "Text";
                    break;
                case DataType.Number:
                    Description = "Number";
                    break;
                case DataType.Date:
                    Description = "Date";
                    break;
                case DataType.Group:
                    Description = "Group";
                    break;
                case DataType.Transform:
                    Description = "Transform";
                    break;
                default:
                    //this stops any undefined data type being added
                    throw new NotSupportedException();
            }

            DataType = type;
            RuleTypes =
                rules.Select(
                    arg =>
                        new RuleTypeInfo(type, arg))
                    .ToList();
        }

 public Ident(string name, IdentType identType, DataType dataType, AstNode node)
 {
     Name = name;
     IdentType = identType;
     DataType = dataType;
     Node = node;
 }

       public  void Update(int fieldId, DataType type)
        {
            var types = type.FieldSettingTypes.Where(t => t.Section == Section).ToArray(); 
           for (var i = 0; i < types.Count(); i++)
            {
                var value = string.Empty;
                var t = types[i].SystemType;
                if (t == "Boolean")
                {
                    var cb = Repeater1.Controls[i].FindControl("Checkbox") as CheckBox;
                    if (cb != null) value = cb.Checked.ToString(CultureInfo.InvariantCulture);
                }
                else
                {
                    var tb = Repeater1.Controls[i].FindControl("Textbox") as TextBox;
                    if (tb != null) value = tb.Text;
                }

                if (t == "Int")
                {
                    value = value.AsInt().ToString(CultureInfo.InvariantCulture);
                }

                var key = types[i].Key;
                if (types[i].VerifySetting (value))
                FieldSettingsController.UpdateFieldSetting(key, value, fieldId);
            }

        }

 /// <summary>
 /// Creates a new instance of the <see cref="DataLoadException"/> class.
 /// </summary>
 /// <param name="inner">The inner exception.</param>
 /// <param name="jsonData">The data that the serializer was trying to load.</param>
 /// <param name="targetType">The target type.</param>
 public DataLoadException(Exception inner, string jsonData, Type targetType, DataType dataType)
     : base("An exception occurred trying to read data into an internal format. Please check that the input data is correct.", inner)
 {
     Data.Add("Target type", targetType.Name);
     Data.Add("Data type", dataType.ToString());
     Data.Add("Data", jsonData);
 }

 public void Show(DataType selectedType)
 {
     TypeName = selectedType.Name;
     SelectedType = selectedType;
     Repeater1.DataSource = selectedType.FieldSettingTypes.Where(t=>t.Section==Section);
     Repeater1.DataBind();
 }

 public void BindData(int fieldId,DataTable  settingsTable, DataType type)
 {
     
     if (!IsPostBack)
     {
         var types = type.FieldSettingTypes.Where(t => t.Section == Section).ToArray();
         for (var i = 0; i < types.Count(); i++)
         {
             var key = types[i].Key;
             var value = settingsTable.GetFieldSetting(key, fieldId);
             if (!string.IsNullOrEmpty(value))
             {
                 var t = type.FieldSettingTypes.ElementAt(i).SystemType;
                 if (t == "Boolean")
                 {
                     var cb = Repeater1.Controls[i].FindControl("Checkbox") as CheckBox;
                     if (cb != null) cb.Checked = value.AsBoolean();
                 }
                 else
                 {
                     var tb = Repeater1.Controls[i].FindControl("Textbox") as TextBox;
                     if (tb != null) tb.Text = value;
                 }
             }
            
         }
     }
 }

        public DefaultMethods(Arebis.CodeGeneration.IGenerationHost _host, IZetboxContext ctx, DataType dt)
            : base(_host)
        {
			this.ctx = ctx;
			this.dt = dt;

        }

 public Event(Controller controller, DataType type, string name, string modifier)
     : base(controller)
 {
     Name = name;
     DataType = type;
     _Modifiers.Add(modifier);
 }

 public Input(string name, DataType type= DataType.Text, bool isOptional=false)
 {
     Id = Guid.NewGuid().ToString();
     Name = name;
     Type = type;
     IsOptional = isOptional;
 }

 /// <summary>
 /// Initializes a new instance of the DatabaseFunctionParameter class with given name, type and mode.
 /// </summary>
 /// <param name="name">Parameter name</param>
 /// <param name="type">Parameter type</param>
 /// <param name="mode">Parameter mode.</param>
 public DatabaseFunctionParameter(string name, DataType type, DatabaseParameterMode mode)
 {
     this.Name = name;
     this.ParameterType = type;
     this.Mode = mode;
     this.Annotations = new List<Annotation>();
 }

        public string GetWriteCmd(int address, string data,DataType dtype)
        {
            int bytes = 0;
            string sWriteData = Utils.CreatePLCWriteData(data, out bytes, dtype);

            return CreateCmd(address, bytes, sWriteData);
        }

 public DataModel(string name, string caption, DataType type)
 {
     this.Name = name;
     this.Caption = string.IsNullOrEmpty(caption) ? name: caption;
     this.Type = type;
     Config = new Config();
 }

        //---------------------------------------------------------------------
        public static void DatatypeQuery(OleDbConnection dbcon, CodeGenerator cg)
        {
            cg.DataTypeList.Clear();
            OleDbCommand cmd = new OleDbCommand("SELECT * FROM DataTypes", dbcon);
            OleDbDataReader dr = cmd.ExecuteReader();

            while (dr.Read())
            {
                DataType curDatatype = new DataType();

                curDatatype.ID = Convert.ToInt32(dr["ID"].ToString());
                curDatatype.DataTypeName = dr["DataTypeName"].ToString();
                curDatatype.CType = dr["CType"].ToString();
                curDatatype.CTypeDef = dr["CTypeDef"].ToString();

                curDatatype.CSType = dr["CSType"].ToString();
                curDatatype.CSTypeDef = dr["CSTypeDef"].ToString();

                curDatatype.VBType = dr["VBType"].ToString();
                curDatatype.VBTypeDef = dr["VBTypeDef"].ToString();

                curDatatype.PythonType = dr["PythonType"].ToString();
                curDatatype.PythonTypeDef = dr["PythonTypeDef"].ToString();

                cg.DataTypeList.Add(curDatatype);
            }

            dr.Close();
        }

        /// <summary>
        ///     Constructor that accepts a data type enumeration
        /// </summary>
        /// <param name="dataType">The <see cref="DataType" /> enum value indicating the type to apply.</param>
        public DataTypeAttribute(DataType dataType)
        {
            DataType = dataType;

            // Set some DisplayFormat for a few specific data types
            switch (dataType)
            {
                case DataType.Date:
                    DisplayFormat = new DisplayFormatAttribute();
                    DisplayFormat.DataFormatString = "{0:d}";
                    DisplayFormat.ApplyFormatInEditMode = true;
                    break;
                case DataType.Time:
                    DisplayFormat = new DisplayFormatAttribute();
                    DisplayFormat.DataFormatString = "{0:t}";
                    DisplayFormat.ApplyFormatInEditMode = true;
                    break;
                case DataType.Currency:
                    DisplayFormat = new DisplayFormatAttribute();
                    DisplayFormat.DataFormatString = "{0:C}";

                    // Don't set ApplyFormatInEditMode for currencies because the currency
                    // symbol can't be parsed
                    break;
            }
        }

        public DataType Normalize(DataType type)
        {
            if (type is TypeVariable)
                return NormalizeVariable((TypeVariable)type);

            return NormalizeNamedType((NamedType)type);
        }