/// <summary>
		/// Convert a halo 1 sound tag to the halo 2 version
		/// </summary>
		/// <param name="halo1"></param>
		/// <param name="halo2"></param>
		/// <returns></returns>
		public bool Definitions(
			Blam.Halo1.Tags.sound_group halo1,
			Tags.sound_group halo2
			)
		{
			return true;
		}

 public void SortBooksByTag(Tags tag)
 {
     books = storageAdapter.Load();
     Comparison<Book> comparison;
     switch (tag)
     {
         case Tags.Title:
             comparison = Book.CompareByTitle;
             break;
         case Tags.Author:
             comparison = Book.CompareByAuthor;
             break;
         case Tags.Year:
             comparison = Book.CompareByYear;
             break;
         case Tags.Languadge:
             comparison = Book.CompareByLanguadge;
             break;
         default:
             comparison = Book.CompareByTitle;
             break;
     }
     books.Sort(comparison);
     Commit();
 }

        public async Task<IHttpActionResult> PutTags(Guid id, Tags tags)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != tags.id)
            {
                return BadRequest();
            }

            db.Entry(tags).State = EntityState.Modified;

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!TagsExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

        /// <summary>
        /// Creates new AdvancesSolverSettings.
        /// </summary>
        /// <param name="baseSettings">Base settings to copy.</param>
        /// <param name="totalPoints">Maximum for points spent in the result tree. (>= 0)</param>
        /// <param name="initialAttributes">Starting attributes of stats that calculations are based on.</param>
        /// <param name="attributeConstraints">The attribute constraints the solver should try to fullfill.</param>
        /// <param name="pseudoAttributeConstraints">The pseudo attribute constraints the solver should try to fullfill.</param>
        /// <param name="weaponClass">WeaponClass used for pseudo attribute calculation.</param>
        /// <param name="tags">Tags used for pseudo attribute calculation.</param>
        /// <param name="offHand">OffHand used for pseudo attribute calculation.</param>
        public AdvancedSolverSettings(SolverSettings baseSettings,
            int totalPoints,
            Dictionary<string, float> initialAttributes,
            Dictionary<string, Tuple<float, double>> attributeConstraints,
            Dictionary<PseudoAttribute, Tuple<float, double>> pseudoAttributeConstraints,
            WeaponClass weaponClass, Tags tags, OffHand offHand)
            : base(baseSettings)
        {
            if (totalPoints < 0) throw new ArgumentOutOfRangeException(nameof(totalPoints), totalPoints, "must be >= 0");

            TotalPoints = totalPoints;
            WeaponClass = weaponClass;
            Tags = tags;
            OffHand = offHand;
            AttributeConstraints = attributeConstraints ?? new Dictionary<string, Tuple<float, double>>();
            PseudoAttributeConstraints = pseudoAttributeConstraints ?? new Dictionary<PseudoAttribute, Tuple<float, double>>();
            InitialAttributes = initialAttributes ?? new Dictionary<string, float>();

            if (AttributeConstraints.Values.Any(tuple => tuple.Item2 < 0 || tuple.Item2 > 1))
                throw new ArgumentException("Weights need to be between 0 and 1", "attributeConstraints");
            if (AttributeConstraints.Values.Any(t => t.Item1 <= 0))
                throw new ArgumentException("Target values need to be greater zero", "attributeConstraints");
            if (PseudoAttributeConstraints.Values.Any(tuple => tuple.Item2 < 0 || tuple.Item2 > 1))
                throw new ArgumentException("Weights need to be between 0 and 1", "pseudoAttributeConstraints");
            if (PseudoAttributeConstraints.Values.Any(t => t.Item1 <= 0))
                throw new ArgumentException("Target values need to be greater zero", "pseudoAttributeConstraints");
        }

 public ScenarioBuilder(string name, string description, Tags tags, FilePosition position)
 {
     this.title = name;
     this.description = description;
     this.position = position;
     this.tags = tags;
 }

 /// <inheritdoc />
 public Windows8TouchHandler(Tags touchTags, Tags mouseTags, Tags penTags, Func<Vector2, Tags, bool, TouchPoint> beginTouch, Action<int, Vector2> moveTouch, Action<int> endTouch, Action<int> cancelTouch) : base(touchTags, beginTouch, moveTouch, endTouch, cancelTouch)
 {
     this.mouseTags = mouseTags;
     this.touchTags = touchTags;
     this.penTags = penTags;
     registerWindowProc(wndProcWin8);
 }

        internal static Tags FromJson(VkResponse response)
        {
            var tags = new Tags();

            tags.Count = response["count"];

            return tags;
        }

 /// <summary>
 /// Initializes a new instance of the <see cref="TouchHandler" /> class.
 /// </summary>
 /// <param name="tags">Tags to add to touches.</param>
 /// <param name="beginTouch">A function called when a new touch is detected. As <see cref="InputSource.beginTouch" /> this function must accept a Vector2 position of the new touch and return an instance of <see cref="TouchPoint" />.</param>
 /// <param name="moveTouch">A function called when a touch is moved. As <see cref="InputSource.moveTouch" /> this function must accept an int id and a Vector2 position.</param>
 /// <param name="endTouch">A function called when a touch is lifted off. As <see cref="InputSource.endTouch" /> this function must accept an int id.</param>
 /// <param name="cancelTouch">A function called when a touch is cancelled. As <see cref="InputSource.cancelTouch" /> this function must accept an int id.</param>
 public TouchHandler(Tags tags, Func<Vector2, Tags, bool, TouchPoint> beginTouch, Action<int, Vector2> moveTouch, Action<int> endTouch, Action<int> cancelTouch)
 {
     this.tags = tags;
     this.beginTouch = beginTouch;
     this.moveTouch = moveTouch;
     this.endTouch = endTouch;
     this.cancelTouch = cancelTouch;
 }

 public ExampleSet(string keyword, string title, string description, Tags tags, GherkinTable table)
 {
     Keyword = keyword;
     Title = title ?? string.Empty;
     Description = description ?? "";
     Tags = tags;
     Table = table;
 }

 public void SetHeader(string keyword, string title, string description, Tags tags, FilePosition position)
 {
     this.keyword = keyword;
     this.title = title;
     this.description = description;
     this.tags = tags;
     this.position = position;
 }

 public ExampleBuilder(string keyword, string name, string description, Tags tags, FilePosition position)
 {
     this.keyword = keyword;
     this.name = name;
     this.description = description;
     this.tags = tags;
     this.position = position;
 }

 public ConditionSettings(Tags tags, OffHand offHand, string[] keystones, WeaponClass weaponClass)
 {
     if (keystones == null) throw new ArgumentNullException("keystones");
     Tags = tags;
     OffHand = offHand;
     Keystones = keystones;
     WeaponClass = weaponClass;
 }

 public Feature(Text title, Tags tags, DescriptionLine[] description, Background background, params Scenario[] scenarios)
 {
     Tags = tags;
     Description = description == null ? string.Empty : string.Join(Environment.NewLine, description.Select(d => d.LineText.Trim()).ToArray());
     Background = background;
     Scenarios = scenarios;
     Title = title.Value;
 }

        public TagDTO Create(Tags tag)
        {
            return new TagDTO(){

                 Url = urlbuilder.Link("GamingStoreRoute", new { id = tag.ID }),
                 Name = tag.Name
              };
        }

 void Awake()
 {
     _tags = FindObjectOfType<Tags>();
     _currencyManager = FindObjectOfType<CurrencyManager>();
     _scoreManager = FindObjectOfType<ScoreManager>();
     _enemyMovement = FindObjectOfType<EnemyMovement>();
     _anim = GetComponent<Animator>();
 }

 /// <summary>
 /// Begin touch in given screen position.
 /// </summary>
 /// <param name="position">Screen position.</param>
 /// <param name="tags">Initial tags.</param>
 /// <returns>Internal touch id.</returns>
 protected virtual ITouch beginTouch(Vector2 position, Tags tags)
 {
     if (CoordinatesRemapper != null)
     {
         position = CoordinatesRemapper.Remap(position);
     }
     return manager.INTERNAL_BeginTouch(position, tags);
 }

 public Scenario(string keyword, string title, string description, Tags tags, ScenarioSteps scenarioSteps)
 {
     Keyword = keyword;
     Title = title;
     Description = description;
     Tags = tags;
     Steps = scenarioSteps ?? new ScenarioSteps();
 }

 public Feature(string title, Tags tags, string description, Background background, params Scenario[] scenarios)
 {
     Tags = tags;
     Description = description ?? string.Empty;
     Background = background;
     Scenarios = scenarios;
     Title = title;
 }

 long GetTagsId(string name, Tags tags) {
   long tags_id;
   string tags_cache_key = CacheKey(tags);
   if (!cache_.Get(tags_cache_key, out tags_id)) {
     tags_id = TagsIdFromDatabase(name, tags);
     cache_.Set(tags_cache_key, tags_id);
   }
   return tags_id;
 }

    private static Tags instantiate(DataSet ds)
    {
        Tags t = new Tags();

        t.Id = Convert.ToInt16(ds.Tables[0].Rows[0]["id"]);
        t.Tag = ds.Tables[0].Rows[0]["tag"].ToString();

        return t;
    }