private bool HandleVariableExcluded(DataTypes.Variables.VariableSave variable, DataTypes.RecursiveVariableFinder rvf) { string rootName = variable.GetRootName(); bool shouldExclude = false; if (rootName == "Texture Top" || rootName == "Texture Left") { var addressMode = rvf.GetValue<TextureAddress>("Texture Address"); shouldExclude = addressMode == TextureAddress.EntireTexture; } if (rootName == "Texture Width" || rootName == "Texture Height") { var addressMode = rvf.GetValue<TextureAddress>("Texture Address"); shouldExclude = addressMode == TextureAddress.EntireTexture || addressMode == TextureAddress.DimensionsBased; } if (rootName == "Texture Width Scale" || rootName == "Texture Height Scale") { var addressMode = rvf.GetValue<TextureAddress>("Texture Address"); shouldExclude = addressMode == TextureAddress.EntireTexture || addressMode == TextureAddress.Custom; } return shouldExclude; }
private static void OnLogTableCreated(object sender, DataTypes.EventHandling.LogTableCreationEventArg e) { var p = e.Params; m_LogTables[e.Id] = new Table(p.TableName, (Logger.DBAccess.Enums.GameSubTypeEnum)Enum.Parse(typeof(Logger.DBAccess.Enums.GameSubTypeEnum), p.Variant.ToString()), p.MinPlayersToStart, p.MaxPlayers, (Logger.DBAccess.Enums.BlindTypeEnum)Enum.Parse(typeof(Logger.DBAccess.Enums.BlindTypeEnum), p.Blind.ToString()), (Logger.DBAccess.Enums.LobbyTypeEnum)Enum.Parse(typeof(Logger.DBAccess.Enums.LobbyTypeEnum), p.Lobby.OptionType.ToString()), (Logger.DBAccess.Enums.LimitTypeEnum)Enum.Parse(typeof(Logger.DBAccess.Enums.LimitTypeEnum), p.Limit.ToString()), m_LogServer); m_LogTables[e.Id].RegisterTable(); m_LogGamesStatus[e.Id] = false; }
private static object CreateAndAddInstanceFromClipboard(string instanceType, DataTypes.ArrowElementSave currentArrowElement, string xmlSerializedString) { object newObject = null; if (instanceType == typeof(AxisAlignedRectangleSave).Name) { AxisAlignedRectangleSave aars = FileManager.XmlDeserializeFromString<AxisAlignedRectangleSave>( xmlSerializedString); currentArrowElement.Rectangles.Add(aars); newObject = aars; } else if (instanceType == typeof(CircleSave).Name) { CircleSave circleSave = FileManager.XmlDeserializeFromString<CircleSave>( xmlSerializedString); currentArrowElement.Circles.Add(circleSave); newObject = circleSave; } else if (instanceType == typeof(SpriteSave).Name) { SpriteSave spriteSave = FileManager.XmlDeserializeFromString<SpriteSave>( xmlSerializedString); currentArrowElement.Sprites.Add(spriteSave); newObject = spriteSave; } return newObject; }
public EhrExtractContent(string archetypeNodeId, DataTypes.Text.DvText name) : base(archetypeNodeId, name) { // TODO: implement SetAttributeDictionary and CheckInvariant overrides SetAttributeDictionary(); CheckInvariants(); }
public Rmessage(Byte data) { Type = DataTypes.BYTESTREAM;//setting type (Bitstream) in object field content = new Byte[8]; //create array with message and header of parameter content[0] = 5; //setting type (Bitstream) content[1] = 1; //setting length (1 byte) content[4] = data; //copying data to send }
public ImpactScienceData(DataTypes dataType, float energy, String biome, double latitude, float amount, float xmitValue, float labBoost, String id, String dataname, bool triggered, uint flightID) : base(amount, xmitValue, labBoost, id, dataname, triggered, flightID) { this.datatype = dataType; kineticEnergy = energy; this.biome = biome; this.latitude = latitude; }
public Musician(DataTypes.MusicianData md, ContentManager cm, SpriteBatch sb) { texture = cm.Load<Texture2D>(md.Texture); map = cm.Load<Dictionary<string, Rectangle>>(md.SpriteMap).Values.ToArray(); position = md.Position; frameRate = md.FrameRate; spriteBatch = sb; }
public ImageSet(ImageCollection collection, int index, DataTypes type, object dataObject) : this(collection, index) { this.DataType = type; this.DataObject = dataObject; this.Status = Statues.None; }
// INPUT CORRECT // This method checks that the player's input corresponds to the expected input - // That they are in the right place and that they are pressing the right thing. public bool inputCorrect(DataTypes.InputType input) { if (stateMachine.CurrentNode == stateMachine.PlayerNode && (input.ToString() == stateMachine.PlayerEdge.NextNodeType.ToString() || ((input.ToString()=="HIT" || input.ToString()=="SNARE"))|| stateMachine.CurrentEdge.NextNodeType.ToString()=="ROLL")){ return true; } else return false; }
private static void OnLogGameCreated(object sender, DataTypes.EventHandling.LogGameEventArg e) { if (m_LogGamesStatus[e.Id]) return; m_LogGamesStatus[e.Id] = true; m_LogGames[e.Id] = new Game(m_LogTables[e.Id]); m_LogGames[e.Id].RegisterGame(); }
internal static byte[] GetBytes(int size, DataTypes[] types, object[] data) { byte[] bytes = new byte[size]; int currentPlace = 0; for (int i = 0; i < types.Length; ++i) { switch (types[i]) { case DataTypes.Bool: BitConverter.GetBytes((bool)data[i]).CopyTo(bytes, currentPlace); break; case DataTypes.DateTime: BitConverter.GetBytes(((DateTime)data[i]).ToBinary()).CopyTo(bytes, currentPlace); break; case DataTypes.Byte: bytes[currentPlace] = (byte)data[i]; break; case DataTypes.Short: BitConverter.GetBytes((short)data[i]).CopyTo(bytes, currentPlace); break; case DataTypes.UShort: BitConverter.GetBytes((ushort)data[i]).CopyTo(bytes, currentPlace); break; case DataTypes.Int: BitConverter.GetBytes((int)data[i]).CopyTo(bytes, currentPlace); break; case DataTypes.UInt: BitConverter.GetBytes((uint)data[i]).CopyTo(bytes, currentPlace); break; case DataTypes.Long: BitConverter.GetBytes((long)data[i]).CopyTo(bytes, currentPlace); break; case DataTypes.ULong: BitConverter.GetBytes((ulong)data[i]).CopyTo(bytes, currentPlace); break; case DataTypes.Float: BitConverter.GetBytes((float)data[i]).CopyTo(bytes, currentPlace); break; case DataTypes.Double: BitConverter.GetBytes((double)data[i]).CopyTo(bytes, currentPlace); break; case DataTypes.Name: string s = ((string)data[i]).PadRight(16); encode.GetBytes(s).CopyTo(bytes, currentPlace); break; case DataTypes.Message: string st = ((string)data[i]).PadRight(64); encode.GetBytes(st).CopyTo(bytes, currentPlace); break; } currentPlace += GetSize(types[i]); } return bytes; }
public AuditDetails(string systemId, DataTypes.Text.DvCodedText changeType) : this() { DesignByContract.Check.Require(!string.IsNullOrEmpty(systemId), "systemId must not be null or empty"); DesignByContract.Check.Require(changeType != null, "changeType must not be null"); this.systemId = systemId; this.timeCommitted = new OpenEhr.RM.DataTypes.Quantity.DateTime.DvDateTime(); this.changeType = changeType; }
public FeederAudit(FeederAuditDetails originatingSystemAudit, AssumedTypes.List<DataTypes.Basic.DvIdentifier> originatingSystemItemIds, DataTypes.Encapsulated.DvEncapsulated originalContent) : this() { Check.Require(originatingSystemAudit != null); this.originatingSystemAudit = originatingSystemAudit; this.originatingSystemItemIds = originatingSystemItemIds; this.originalContent = originalContent; }
/// <summary> /// Constructs a new tile /// </summary> /// <param name="position">Initial position of the tile</param> /// <param name="texture">Texture content to render</param> /// <param name="collision">Collision type used for collision resolution</param> public Tile(Vector2 position, Texture2D texture, DataTypes.CollisionType collision) { colliding = false; this.position = position; prevPosition = position; this.texture = texture; this.collisionType = collision; this.forces = new List<Vector2>(); this.impulses = new List<Vector2>(); }
// System ID is not set here, expecting it top be set by the server public AuditDetails(DataTypes.Text.DvCodedText changeType, PartyProxy committer) : this() { DesignByContract.Check.Require(changeType != null, "changeType must not be null"); DesignByContract.Check.Require(committer != null, "committer must not be null"); this.changeType = changeType; this.committer = committer; this.CheckDefaultInvariants(); }
public StateMachine(DataTypes.BitmapUnsafe bitmap, List<State> states) { _bitmap = bitmap; _states = states; startx = rand.Next(0, bitmap.Width); starty = rand.Next(0, bitmap.Height); startstate = states[rand.Next(0, states.Count)]; Reset(); }
int rowSize; //Number of bytes in each row #endregion Fields #region Constructors internal Table(string _path, DataTypes[] types, int size) { path = _path; dataTypes = types; rowSize = size; if (!File.Exists(path)) File.Create(path); GetRowCount(); }
public Link(DataTypes.Text.DvText meaning, DataTypes.Text.DvText type, DataTypes.Uri.DvEhrUri target) : this() { Check.Require(meaning != null && type != null && target != null); this.meaning = meaning; this.type = type; this.target = target; CheckInvariants(); }
public Rmessage(Int32 data) { Type = DataTypes.INT; content = new Byte[8]; Byte[] val = BitConverter.GetBytes(data); Byte[] btype = BitConverter.GetBytes((int)Type); Array.Copy(btype, 0, content, 0, 4); Array.Copy(val, 0, content, 4, 4); content[1] = 4; }
public void GenerateCSharpSignature(DataTypes types, LrpStream stream) { if (this.Direction == ParameterDirection.InOut) { stream.Write("ref "); } else if (this.Direction == ParameterDirection.Out) { stream.Write("out "); } stream.Write("{0} {1}", types.ToCSharpFullName(this.Type), this.Name); }
protected ExtractLocatable(string archetypeNodeId, DataTypes.Text.DvText name) : this() { Check.Require(!string.IsNullOrEmpty(archetypeNodeId), "archetype node id must not be null or empty"); this.archetypeNodeId = archetypeNodeId; Check.Require(name != null, "name must not be null"); Check.Require(!string.IsNullOrEmpty(name.Value), "name value must not be null or empty"); this.name = name; Check.Invariant(attributesDictionary != null, "Attributes diction must not be null"); }
/// <summary> /// constructor /// </summary> /// <param name="systemId"></param> /// <param name="location"></param> /// <param name="provider"></param> /// <param name="subject"></param> /// <param name="time"></param> /// <param name="versionId"></param> public FeederAuditDetails(string systemId, Common.Generic.PartyIdentified location, Common.Generic.PartyIdentified provider, Common.Generic.PartyProxy subject, DataTypes.Quantity.DateTime.DvDateTime time, string versionId) : this() { this.systemId = systemId; this.location = location; this.provider = provider; this.subject = subject; this.time = time; this.versionId = versionId; }
void OnProjectLoad(DataTypes.GumProjectSave obj) { if (obj != null && !string.IsNullOrEmpty(obj.FullFileName)) { string fileName = obj.FullFileName; MainWindow.Text = "Gum: " + fileName; } else { MainWindow.Text = "Gum"; } }
public IsmTransition(DataTypes.Text.DvCodedText currentState, DataTypes.Text.DvCodedText transition, DataTypes.Text.DvCodedText careflowStep) : this() { Check.Require(currentState != null, "current_state must not be null"); this.currentState = currentState; this.transition = transition; this.careflowStep = careflowStep; SetAttributeDictionary(); this.SetAttributeDictionary(); }
readonly int _rowSize; //Number of bytes in each row #endregion Fields #region Constructors internal Table(Database _database, string name, string path, DataTypes[] types, int size) { database = _database; _name = name; _path = path; _dataTypes = types; _rowSize = size; _dataPositions = database.GetPositions(_dataTypes); //Open the file but dont close it until the table needs "unloaded" _fileStream = File.Open(_path, FileMode.OpenOrCreate); GetRowCount(); }
public ExtractChapter(string archetypeNodeId, DataTypes.Text.DvText name, ExtractEntityIdentifier entityIdentifer, ExtractEntityContent content) : base(archetypeNodeId, name) { // TODO: Set attribute values this.entityIdentifier = entityIdentifer; this.content = content; // TODO: implement SetAttributeDictionary and CheckInvariant overrides SetAttributeDictionary(); CheckInvariants(); DesignByContract.Check.Ensure(EntityIdentifier != null, "EntityIdentifier must not be null"); DesignByContract.Check.Ensure(Content != null, "Content must not be null"); }
public City(DataTypes.WorldData.City c) { AbsolutePosition = c.Position; RelativePosition = c.Position; State = c.State; clearedDialogue = new DialogModel(c.ClearedDialogAsset); unlockedDialogue = new DialogModel(c.UnlockedDialogAsset); newlyUnlockedDialogue = new DialogModel(c.NewlyUnlockedDialogAsset); successDialogue = new DialogModel(c.SuccessAsset); Name = c.Name; Unlocked = new Models.City[] { null, null, null }; Data = c; }
public static StateMachine FromString(DataTypes.BitmapUnsafe image, string value, int maxstates) { StateMachine retval = new StateMachine(); retval._bitmap = image; value = value.Substring(1); if (value[0] != 's') throw new Exception("wrong function for dupmachine"); value = value.Substring(1); int index; index = value.IndexOf('i'); int statecount = Convert.ToInt32(value.Substring(0, index)); value = value.Substring(index + 1); index = value.IndexOf('x'); int initialstate = Convert.ToInt32(value.Substring(0, index)); value = value.Substring(index + 1); index = value.IndexOf('y'); retval.startx = Convert.ToInt32(value.Substring(0, index)); value = value.Substring(index + 1); index = value.IndexOf('['); retval.starty = Convert.ToInt32(value.Substring(0, index)); value = value.Substring(index); retval._states = new List<State>(); for (int n = 0; n < statecount; n++) { index = value.IndexOf(']'); retval._states.Add(State.FromString(value.Substring(0, index + 1), maxstates)); value = value.Substring(index + 1); } if (value != ")") throw new Exception("end mismatch"); retval.startstate = retval._states[initialstate]; retval.Reset(); return retval; }
public Rmessage(String data) { Type = DataTypes.STRING; Byte[] input = ASCIIEncoding.ASCII.GetBytes(data); Int32 PacketLength = 4; while ((input.Length + 1) > PacketLength) PacketLength += 4; content = new Byte[4 + PacketLength]; Array.Copy(input, 0, content, 4, input.Length); Byte[] length = BitConverter.GetBytes(PacketLength); Array.Copy(length, 0, content, 1, 3); content[0] = (byte)Type; }
public Participation(DataTypes.Text.DvText function, DataTypes.Quantity.DvInterval<DataTypes.Quantity.DateTime.DvDateTime> time, DataTypes.Text.DvCodedText mode, PartyProxy performer) : this() { Check.Require(function != null, "function must not be null."); Check.Require(mode != null, "mode must not be null"); Check.Require(performer != null, "performer must not be null"); this.function = function; this.time = time; this.mode = mode; this.performer = performer; this.CheckStrictInvariants(); }
public override void read(DataTypes dataTypes, List <byte> data) { reason = dataTypes.ReadNextString(data); }
IInsertUpdateBuilderDynamic IInsertUpdateBuilderDynamic.Column(string columnName, object value, DataTypes parameterType, int size) { base.xcd08eddb14ea4239.x4fe829ca2eecf51e(columnName, value, parameterType, size); return(this); }
/// <summary> /// Finds the targets for the specified reference. /// </summary> private static void UpdateInstanceDescriptions(Session session, List <AeEventAttribute> instances, bool throwOnError) { try { ReadValueIdCollection nodesToRead = new ReadValueIdCollection(); for (int ii = 0; ii < instances.Count; ii++) { ReadValueId nodeToRead = new ReadValueId(); nodeToRead.NodeId = instances[ii].NodeId; nodeToRead.AttributeId = Attributes.Description; nodesToRead.Add(nodeToRead); nodeToRead = new ReadValueId(); nodeToRead.NodeId = instances[ii].NodeId; nodeToRead.AttributeId = Attributes.DataType; nodesToRead.Add(nodeToRead); nodeToRead = new ReadValueId(); nodeToRead.NodeId = instances[ii].NodeId; nodeToRead.AttributeId = Attributes.ValueRank; nodesToRead.Add(nodeToRead); } // start the browse operation. DataValueCollection results = null; DiagnosticInfoCollection diagnosticInfos = null; session.Read( null, 0, TimestampsToReturn.Neither, nodesToRead, out results, out diagnosticInfos); ClientBase.ValidateResponse(results, nodesToRead); ClientBase.ValidateDiagnosticInfos(diagnosticInfos, nodesToRead); // update the instances. for (int ii = 0; ii < nodesToRead.Count; ii += 3) { AeEventAttribute instance = instances[ii / 3]; instance.Description = results[ii].GetValue <LocalizedText>(LocalizedText.Null).Text; instance.DataType = results[ii + 1].GetValue <NodeId>(NodeId.Null); instance.ValueRank = results[ii + 2].GetValue <int>(ValueRanks.Any); if (!NodeId.IsNull(instance.DataType)) { instance.BuiltInType = DataTypes.GetBuiltInType(instance.DataType, session.TypeTree); } } } catch (Exception exception) { if (throwOnError) { throw new ServiceResultException(exception, StatusCodes.BadUnexpectedError); } } }
public void ShouldConvertDate(string input, string expected) { var result = DataTypes.ToLocalDateTime(input); Assert.Equal(expected, result.Value.ToString("yyyyMMdd")); }
public IDeleteBuilder Where(string columnName, object value, DataTypes parameterType, int size) { Actions.ColumnValueAction(columnName, value, parameterType, size); return(this); }
/// <summary> /// Implements Validate method from <see cref="IValidatableObject" /> interface /// </summary> /// <param name="validationContext">Context the validation runs in</param> /// <returns>List of validation results if any</returns> IEnumerable <ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { var validationResults = new List <ValidationResult>(); foreach (var nodeTypeKeyValue in NodeTypes) { nodeTypeKeyValue.Value.SetDerivedFromToRoot(nodeTypeKeyValue.Key); foreach (var requirementKeyValue in nodeTypeKeyValue.Value.Requirements.SelectMany(r => r).ToArray()) { if (!string.IsNullOrEmpty(requirementKeyValue.Value.Node) && !NodeTypes.ContainsKey(requirementKeyValue.Value.Node)) { validationResults.Add(CreateRequirementValidationResult(requirementKeyValue, nodeTypeKeyValue)); } } foreach (var capabilityKeyValue in nodeTypeKeyValue.Value.Capabilities) { if (!CapabilityTypes.ContainsKey(capabilityKeyValue.Value.Type)) { validationResults.Add(CreateCapabilityTypeValidationResult(nodeTypeKeyValue.Key, capabilityKeyValue.Value.Type, capabilityKeyValue.Key)); } } foreach (var complexDataTypeKeyValue in DataTypes) { foreach (var basicDatatypeKeyValue in complexDataTypeKeyValue.Value.Properties) { var basicType = basicDatatypeKeyValue.Value.Type; if (!DataTypes.ContainsKey(basicType)) { validationResults.Add(new ValidationResult( string.Format("Data type '{0}' specified as part of data type '{1}' not found.", basicType, complexDataTypeKeyValue.Key))); } } } var circularDependencyValidationResults = nodeTypeKeyValue.Value.ValidateCircularDependency().ToList(); if (circularDependencyValidationResults.Any()) { return(validationResults.Concat(circularDependencyValidationResults)); } } var importCircularValidationResults = ValidateImportsCircularDependency(); if (importCircularValidationResults.Any()) { return(validationResults.Concat(importCircularValidationResults)); } if (!validationResults.Any()) { var requirementsGraph = new ToscaNodeTypeRequirementsGraph(this); if (requirementsGraph.ContainsCyclicLoop()) { validationResults.Add(new ValidationResult("Circular dependency detected by requirements on node type")); } } return(validationResults); }
public TCNetDataHeader(DataTypes data) : base(MessageTypes.Data) { DataType = data; }
public static Exception IntDeserializationFailure(DataTypes type) { return(new SerializationException($"Waited for an int, got {type:G} (0x{type:X})")); }
public DataBase(DataTypes DataType) { Type = DataType; }
/// <summary> /// Initializes a new instance of the Field class using specified parameters. /// </summary> /// <param name="dataType">Type of data field.</param> /// <param name="value">Content of a field.</param> public Field(DataTypes dataType, object value) { DataType = dataType; Value = value; }
public DataBase(byte[] Data, ref int offset, DataTypes DataType) : this(DataType) { Parse(Data, ref offset); }
public DataItem(short index, DataTypes dataType, byte[] data) { Index = index; DataType = dataType; Data = data; }
public static FileFactory ForExtension(string extension) { return(ForDataType(DataTypes.ForExtension(extension))); }
public void ConvertEntityContainer() { var taupoModel = new EntityModelSchema() { new EntityContainer("MyContainer") { new EntitySet("Customers", "Customer"), new EntitySet("Orders", "Order") { new AttributeAnnotation() { Content = new XAttribute(this.annotationNamespace + "foo1", "bar1") }, }, new AssociationSet("CustomerOrders", "CustomerOrder") { new AssociationSetEnd("Order", "Orders"), new AssociationSetEnd("Customer", "Customers") }, new FunctionImport("FunctionImport1") { ReturnTypes = { new FunctionImportReturnType(DataTypes.CollectionOfEntities("Customer"), "Customers") }, Parameters = { new FunctionParameter("ExcludingId", EdmDataTypes.Int32) }, Annotations = { new AttributeAnnotation() { Content = new XAttribute(this.annotationNamespace + "foo5", "bar5") } }, }, new AttributeAnnotation() { Content = new XAttribute(this.annotationNamespace + "foo4", "bar4") }, }, new EntityType("Customer") { new MemberProperty("Id", EdmDataTypes.Int32) { IsPrimaryKey = true }, }, new EntityType("Order") { new MemberProperty("Id", EdmDataTypes.Int32) { IsPrimaryKey = true }, }, new AssociationType("CustomerOrder") { new AssociationEnd("Customer", "Customer", EndMultiplicity.One, OperationAction.Cascade), new AssociationEnd("Order", "Order", EndMultiplicity.Many), }, } .ApplyDefaultNamespace("NS1") .Resolve(); IEdmModel result = this.converter.ConvertToEdmModel(taupoModel); IEdmEntityType customer = (IEdmEntityType)result.FindType("NS1.Customer"); IEdmEntityType order = (IEdmEntityType)result.FindType("NS1.Order"); IEdmEntityContainer convertedContainer = result.EntityContainer; Assert.AreEqual("MyContainer", convertedContainer.Name); Assert.AreEqual(3, convertedContainer.Elements.Count()); Assert.AreEqual(2, convertedContainer.Elements.OfType <IEdmEntitySet>().Count()); Assert.AreEqual(1, convertedContainer.Elements.OfType <IEdmOperationImport>().Count()); Assert.AreEqual(1, result.DirectValueAnnotations(convertedContainer).Count()); Assert.AreEqual("bogus", result.DirectValueAnnotations(convertedContainer).First().NamespaceUri); Assert.AreEqual("foo4", result.DirectValueAnnotations(convertedContainer).First().Name); Assert.AreEqual("bar4", (((IEdmDirectValueAnnotation)result.DirectValueAnnotations(convertedContainer).First()).Value as IEdmStringValue).Value); IEdmEntitySet convertedCustomerSet = convertedContainer.Elements.OfType <IEdmEntitySet>().ElementAt(0); Assert.AreEqual("Customers", convertedCustomerSet.Name); Assert.AreEqual(result.FindType("NS1.Customer"), convertedCustomerSet.ElementType); Assert.AreEqual(0, result.DirectValueAnnotations(convertedCustomerSet).Count(a => a.NamespaceUri == "bogus")); IEdmEntitySet convertedOrderSet = convertedContainer.Elements.OfType <IEdmEntitySet>().ElementAt(1); Assert.AreEqual("Orders", convertedOrderSet.Name); Assert.AreEqual(result.FindType("NS1.Order"), convertedOrderSet.ElementType); var annotations = result.DirectValueAnnotations(convertedOrderSet).Where(a => a.NamespaceUri == "bogus"); Assert.AreEqual(1, annotations.Count()); Assert.AreEqual("foo1", annotations.First().Name); Assert.AreEqual("bar1", (((IEdmDirectValueAnnotation)annotations.First()).Value as IEdmStringValue).Value); var toOrder = customer.NavigationProperties().First(); Assert.AreSame(convertedOrderSet, convertedCustomerSet.FindNavigationTarget(toOrder)); Assert.AreEqual("CustomerOrders", result.GetAssociationSetName(convertedCustomerSet, toOrder)); var toCustomer = order.NavigationProperties().First(); Assert.AreSame(convertedCustomerSet, convertedOrderSet.FindNavigationTarget(toCustomer)); Assert.AreEqual("CustomerOrders", result.GetAssociationSetName(convertedOrderSet, toCustomer)); IEdmOperationImport convertedFunctionImport = convertedContainer.Elements.OfType <IEdmOperationImport>().First(); Assert.AreEqual("FunctionImport1", convertedFunctionImport.Name); IEdmEntitySet eset; Assert.IsTrue(convertedFunctionImport.TryGetStaticEntitySet(out eset)); Assert.AreEqual(convertedCustomerSet, eset); Assert.AreEqual(EdmTypeKind.Collection, convertedFunctionImport.ReturnType.TypeKind()); Assert.AreEqual(null, convertedFunctionImport.ReturnType.FullName()); Assert.AreEqual(1, convertedFunctionImport.Parameters.Count()); Assert.AreEqual("ExcludingId", convertedFunctionImport.Parameters.First().Name); Assert.AreEqual(EdmTypeKind.Primitive, convertedFunctionImport.Parameters.First().Type.TypeKind()); Assert.AreEqual(1, result.DirectValueAnnotations(convertedFunctionImport).Count()); Assert.AreEqual("bogus", result.DirectValueAnnotations(convertedFunctionImport).First().NamespaceUri); Assert.AreEqual("foo5", result.DirectValueAnnotations(convertedFunctionImport).First().Name); Assert.AreEqual("bar5", (((IEdmDirectValueAnnotation)result.DirectValueAnnotations(convertedFunctionImport).First()).Value as IEdmStringValue).Value); }
public void ShouldConvertDateTextToISODate(string input, string expected) { var result = DataTypes.HL7DateTextAsISODateText(input); Assert.Equal(expected, result); }
public virtual IUpdateBuilder Where(string columnName, object value, DataTypes parameterType, int size) { Actions.WhereAction(columnName, value, parameterType, size); return(this); }
/// <summary> /// Collects instance declarations nodes from with a type. /// </summary> public static void CollectInstanceDeclarations( Session session, ComNamespaceMapper mapper, NodeState node, AeEventAttribute parent, List <AeEventAttribute> instances, IDictionary <string, AeEventAttribute> map) { List <BaseInstanceState> children = new List <BaseInstanceState>(); node.GetChildren(session.SystemContext, children); if (children.Count == 0) { return; } // process the children. for (int ii = 0; ii < children.Count; ii++) { BaseInstanceState instance = children[ii]; // only interested in objects and variables. if (instance.NodeClass != NodeClass.Object && instance.NodeClass != NodeClass.Variable) { return; } // ignore instances without a modelling rule. if (NodeId.IsNull(instance.ModellingRuleId)) { return; } // create a new declaration. AeEventAttribute declaration = new AeEventAttribute(); declaration.RootTypeId = (parent != null)?parent.RootTypeId:node.NodeId; declaration.NodeId = (NodeId)instance.NodeId; declaration.BrowseName = instance.BrowseName; declaration.NodeClass = instance.NodeClass; declaration.Description = (instance.Description != null)?instance.Description.ToString():null; // get data type information. BaseVariableState variable = instance as BaseVariableState; if (variable != null) { declaration.DataType = variable.DataType; declaration.ValueRank = variable.ValueRank; if (!NodeId.IsNull(variable.DataType)) { declaration.BuiltInType = DataTypes.GetBuiltInType(declaration.DataType, session.TypeTree); } } if (!LocalizedText.IsNullOrEmpty(instance.DisplayName)) { declaration.DisplayName = instance.DisplayName.Text; } else { declaration.DisplayName = instance.BrowseName.Name; } if (parent != null) { declaration.BrowsePath = new QualifiedNameCollection(parent.BrowsePath); declaration.BrowsePathDisplayText = Utils.Format("{0}/{1}", parent.BrowsePathDisplayText, mapper.GetLocalBrowseName(instance.BrowseName)); declaration.DisplayPath = Utils.Format("{0}/{1}", parent.DisplayPath, instance.DisplayName); } else { declaration.BrowsePath = new QualifiedNameCollection(); declaration.BrowsePathDisplayText = Utils.Format("{0}", instance.BrowseName); declaration.DisplayPath = Utils.Format("{0}", instance.DisplayName); } declaration.BrowsePath.Add(instance.BrowseName); // check if reading an overridden declaration. AeEventAttribute overriden = null; if (map.TryGetValue(declaration.BrowsePathDisplayText, out overriden)) { declaration.OverriddenDeclaration = overriden; } map[declaration.BrowsePathDisplayText] = declaration; // only interested in variables. if (instance.NodeClass == NodeClass.Variable) { instances.Add(declaration); } // recusively build tree. CollectInstanceDeclarations(session, mapper, instance, declaration, instances, map); } }
IInsertUpdateBuilder IInsertUpdateBuilder.Column(string columnName, object value, DataTypes parameterType, int size) { Actions.ColumnValueAction(columnName, value, parameterType, size); return(this); }
IInsertUpdateBuilderDynamic IInsertUpdateBuilderDynamic.Column(string propertyName, DataTypes parameterType, int size) { base.xcd08eddb14ea4239.xbb4ee78ca371cf6a((ExpandoObject)base.x6b73aa01aa019d3a.Item, propertyName, parameterType, size); return(this); }
public bool IsIgnoreInfoSource(DataTypes type, IgnoreInfoSourceOptions ignoreInfoSourceOptions) { return(_inclusionControls[type].IsIgnoreInfoSource(ignoreInfoSourceOptions)); }
private static data.tmpDS.marketDataDataTable GetMarketData(DateTime frDate, DateTime toDate, commonClass.AppTypes.TimeScale timeScale, string stockCodeList, DataTypes type) { string sqlCond = ""; if (timeScale != commonClass.AppTypes.MainDataTimeScale) { sqlCond += (sqlCond == "" ? "" : " AND ") + " type='" + timeScale.Code + "'"; } sqlCond += (sqlCond == "" ? "" : " AND ") + "onDate BETWEEN '" + common.system.ConvertToSQLDateString(frDate) + "'" + " AND '" + common.system.ConvertToSQLDateString(toDate) + "'"; sqlCond += (sqlCond == "" ? "" : " AND "); switch (type) { case DataTypes.Advancing: sqlCond += "closePrice>openPrice"; break; case DataTypes.Declining: sqlCond += "closePrice<openPrice"; break; default: sqlCond += "closePrice=openPrice"; break; } if (stockCodeList != null && stockCodeList != "") { sqlCond += (sqlCond == "" ? "" : " AND ") + " stockCode IN (" + stockCodeList + ")"; } else { sqlCond += (sqlCond == "" ? "" : " AND ") + " stockCode IN (SELECT code FROM stockCode WHERE status & " + ((byte)commonClass.AppTypes.CommonStatus.Enable).ToString() + ">0)"; } string sqlCmd = "SELECT onDate,COUNT(*) AS val0,SUM(volume) AS val1" + " FROM " + (timeScale == commonClass.AppTypes.MainDataTimeScale ? "priceData" : "priceDataSum") + " WHERE " + sqlCond + " GROUP BY onDate ORDER BY onDate"; data.tmpDS.marketDataDataTable tbl = new data.tmpDS.marketDataDataTable(); DbAccess.LoadFromSQL(tbl, sqlCmd); return(tbl); }
protected override List <ColumnSchema> GetProcedureResultColumns(DataTable resultTable) { return (( from r in resultTable.AsEnumerable() let systemType = r.Field <Type>("DataType") let columnName = GetEmptyStringIfInvalidColumnName(r.Field <string>("ColumnName")) let providerType = Converter.ChangeTypeTo <int>(r["ProviderType"]) let dataType = DataTypes.FirstOrDefault(t => t.ProviderDbType == providerType) let columnType = dataType == null ? null : dataType.TypeName let length = r.Field <int>("ColumnSize") let precision = Converter.ChangeTypeTo <int>(r["NumericPrecision"]) let scale = Converter.ChangeTypeTo <int>(r["NumericScale"]) let isNullable = Converter.ChangeTypeTo <bool>(r["AllowDBNull"]) select new ColumnSchema { ColumnType = GetDbType(columnType, dataType, length, precision, scale, null, null, null), ColumnName = columnName, IsNullable = isNullable, MemberName = ToValidName(columnName), MemberType = ToTypeName(systemType, isNullable), SystemType = systemType ?? typeof(object), DataType = GetDataType(columnType, null, length, precision, scale), ProviderSpecificType = GetProviderSpecificType(columnType), } ).ToList()); }
public override byte[] write(DataTypes dataTypes) { throw new System.NotImplementedException(); }
public override void Add() { var folderId = DataTypes.CreateFolder("Aub.Blogs"); DataTypes.CreateFromFolder("~/App_Data/Aubergine/Blog/DataTypes/", folderId); }
protected override void Execute() { // init patch directory if (flags.Has("init")) { string deployDirectory = Helpers.AbsolutePath(arguments.Length > 0 ? arguments[0] : "autopatch"); string deployFilePath = Path.ChangeExtension(deployDirectory, Constants.ydr); Dictionary <string, string> targets = new Dictionary <string, string>(); for (int i = 1; i < arguments.Length; i++) { // parse targets in format name:path or just path string[] tmp = arguments[i].Split(new[] { ':' }, 2, StringSplitOptions.RemoveEmptyEntries); string name = tmp.Length > 1 && tmp[0].Length > 1 ? tmp[0] : Path.GetFileName(tmp[0]); string path = Helpers.AbsolutePath(tmp.Length > 1 && tmp[0].Length > 1 ? tmp[1] : tmp[0]); targets.Add(name, path); } if (targets.Count == 0) { Fail("No target directories specified"); } Directory.CreateDirectory(deployDirectory); int fileCount = 0; dynamic info = new JObject(); info.build = 0; info.nameschema = "inc.{buildno}.{target}.patch.ykc"; info.deploydir = deployDirectory; info.targets = new JArray(); foreach (var targetInfo in targets) { string targetName = targetInfo.Key; string targetPath = targetInfo.Value; string[] files = Directory.GetFiles(targetPath, "*", SearchOption.AllDirectories); dynamic target = new JObject(); { target.name = targetName; target.path = targetPath; target.files = new JArray(); foreach (string file in files) { // ignore unknown file types and hidden files if (!DataTypes.ForExtension(DataTypes.BaseExtension(Path.GetExtension(file))).IncludeInArchive()) { continue; } if (new FileInfo(file).Attributes.HasFlag(FileAttributes.Hidden)) { continue; } dynamic entry = new JObject(); { entry.name = Helpers.RelativePath(file, targetPath); entry.size = Helpers.FileSize(file); entry.hash = Helpers.FileHash(file); entry.version = 0; } target.files.Add(entry); fileCount++; } } info.targets.Add(target); Log("Added target '" + targetName + "' (" + target.files.Count + " files) [" + targetPath + "]", ConsoleColor.Yellow); } Log("Successfully added " + fileCount + " file in " + info.targets.Count + " targets", ConsoleColor.Green); File.WriteAllText(deployFilePath, JsonConvert.SerializeObject(info, Formatting.Indented)); } else { if (arguments.Length == 0) { Fail("No target file specified"); } string deployFilePath = Helpers.AbsolutePath(arguments[0]); int changedFiles = 0, newFiles = 0; if (deployFilePath.EndsWith(Constants.ydr, StringComparison.OrdinalIgnoreCase)) { dynamic info = JsonConvert.DeserializeObject(File.ReadAllText(deployFilePath)); info.build = (int)info.build + 1; foreach (var target in info.targets) { List <string> includedFiles = new List <string>(); string[] files = Directory.GetFiles((string)target.path, "*", SearchOption.AllDirectories); foreach (string file in files) { string localName = Helpers.RelativePath(file, (string)target.path); // ignore unknown file types and hidden files if (!DataTypes.ForExtension(DataTypes.BaseExtension(Path.GetExtension(localName))).IncludeInArchive()) { continue; } if (new FileInfo(file).Attributes.HasFlag(FileAttributes.Hidden)) { continue; } bool include = true, exists = false; foreach (var localFile in target.files) { if (localName.Equals((string)localFile.name, StringComparison.OrdinalIgnoreCase)) { exists = true; string hash = Helpers.FileHash(file); long size = Helpers.FileSize(file); if (size != (long)localFile.size || !hash.Equals((string)localFile.hash)) { // update file entry if files differ localFile.size = size; localFile.hash = hash; localFile.version = (int)localFile.version + 1; } else { include = false; } break; } } if (!exists) { Log("[New file] " + localName, ConsoleColor.Green); dynamic entry = new JObject(); { entry.name = localName; entry.size = Helpers.FileSize(file); entry.hash = Helpers.FileHash(file); entry.version = 1; } target.files.Add(entry); newFiles++; } if (include) { string mainFile = Path.ChangeExtension(localName, DataTypes.BaseExtension(Path.GetExtension(localName))); if (!includedFiles.Contains(mainFile)) { includedFiles.Add(mainFile); if (exists) { Log("[Changed] " + localName, ConsoleColor.Yellow); } if (exists) { changedFiles++; } } } else { Log("[Up to date] " + localName, ConsoleColor.Red); } // Log(include ? exists ? "Changed" : "New file" : "Up to date", ConsoleColor.Cyan); } if (includedFiles.Count > 0) { bool verbose = flags.Has('v'); flags.Unset('v'); YukaArchive archive = new YukaArchive(); foreach (string file in includedFiles) { dynamic factory = FileFactory.ForExtension(Path.GetExtension(file)); if (factory != null) { string realname = Path.ChangeExtension(file, DataTypes.ForExtension(Path.GetExtension(file)).BinaryExtension()); Console.WriteLine(realname); dynamic data = factory.FromSource(Path.Combine((string)target.path, file)); MemoryStream ms = new MemoryStream(); factory.ToBinary(data, ms); archive.files[realname] = ms; } } string name = (string)info.nameschema; name = name.Replace("{buildno}", ((int)info.build).ToString("D3")); name = name.Replace("{target}", ((string)target.name)); name = name.Replace("{date}", DateTime.Now.ToString("yyyy-MM-dd")); name = name.Replace("{time}", DateTime.Now.ToString("HH-mm-ss")); ArchiveFactory.Instance.ToSource(archive, Path.Combine((string)info.deploydir, name)); if (verbose) { flags.Set('v'); } } } Log("Deployed " + newFiles + " new files and " + changedFiles + " updates", ConsoleColor.Green); File.WriteAllText(deployFilePath, JsonConvert.SerializeObject(info, Formatting.Indented)); } } if (flags.Has('w')) { Console.ReadLine(); } }
/// <summary> /// Adds or replaces the cache value of the implicitly given type. /// </summary> /// <param name="dataType">The type of the cache entry.</param> /// <param name="value">The actual data.</param> /// <param name="timeOfAquisition">The time at which the data has been aquired.</param> /// <typeparam name="TCacheValue">The type of the cache value.</typeparam> public void AddOrReplaceCacheValue <TCacheValue>(DataTypes dataType, TCacheValue value, DateTime timeOfAquisition) where TCacheValue : class { this.cacheData[dataType] = new CacheDataSet <TCacheValue>(value, timeOfAquisition); }
public static Exception UnexpectedDataType(DataTypes expected, DataTypes actual) { return(new ArgumentException($"Unexpected data type: {expected} is expected, but got {actual}.")); }
public DataBase(Wxv.Swg.Common.Files.IFFFile.Node Source, ref int offset, DataTypes DataType) : this(DataType) { Parse(Source, ref offset); }
public static Exception BadTypeException(DataTypes actual, params DataTypes[] expectedCodes) { return(new SerializationException($"Got {actual:G} (0x{actual:X}), while expecting one of these: {String.Join(", ", expectedCodes)}")); }
void setNumTextColor(DataTypes.BiomeType biome) { LevelNum.GetComponent <Shadow>().effectColor = DataTypes.GetButtonColorFrom(biome); }