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;
        }

        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;
        }

 // 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();
        }

        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>();
 }

        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();
        }

 /// <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;
 }

        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");
        }

 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);
 }