public TagValue(ITag tag, object value)
        {
            if (tag == null) throw new ArgumentNullException("tag");

            Tag = tag;
            Value = value;
        }

        public override bool IsEditTag(ITag tag)
        {
            // Cache the FieldInfo/PropertyInfo since we will be using it a lot
            if (AttributeIdFieldInfo == null)
            {
                Type type = tag.GetType();
                AttributeIdFieldInfo = type.GetField("myAttributeId", BindingFlags.Instance | BindingFlags.NonPublic);
            }

            if (AttributeIdFieldInfo == null)
            {
                return false;
            }

            var value = AttributeIdFieldInfo.GetValue(tag) as string;
            if (value == null)
            {
                return false;
            }

            switch (value)
            {
                case ExternalEditAttribute1:
                case ExternalEditAttribute2:
                case ExternalEditAttribute3:
                    return true;
                default:
                    return false;
            }
        }

 private void GuardPresenceOfCategoriesOnTag(ITag tag)
 {
     Type tagType = tag.GetType();
     object[] categories = tagType.GetCustomAttributes(typeof(CategoryAttribute), true);
     Assert.That(categories.Length, Is.EqualTo(1));
     Console.WriteLine(((CategoryAttribute) categories[0]).Category);
 }

 public void Validate(ITag tag)
 {
     foreach (var validator in _validators)
     {
         validator?.Validate(tag);
     }
 }

 public Photo(FileInfo file, ITag parent)
 {
     this.file = file;
     this.parent = parent;
     this.id = CryptoUtil.Md5Encode(file.FullName);
     metaReader = JpegMetadataReader.RetreiveFromFile(file.FullName);
 }

		/// <summary>
		/// 
		/// </summary>
		/// <param name="tag"></param>
		public override void VisitTag(ITag tag)
		{
			if (IsPreTag(tag))
			{
				preTagBeingProcessed = true;
			}
		}

        public TagViewModel(ITag tag)
        {
            if (tag == null)
                throw new ArgumentNullException("tag");

            this.tag = tag;
        }

    public override void Write(ITag value, NbtOptions options)
    {
      if (options.HasFlag(NbtOptions.Header) && value.Type != TagType.End)
        this.WriteHeader(value);

      switch (value.Type)
      {
        case TagType.End:
          this.WriteEnd();
          break;

        case TagType.Byte:
          this.Write((byte)value.Value);
          break;

        case TagType.Short:
          this.Write((short)value.Value);
          break;

        case TagType.Int:
          this.Write((int)value.Value);
          break;

        case TagType.Long:
          this.Write((long)value.Value);
          break;

        case TagType.Float:
          this.Write((float)value.Value);
          break;

        case TagType.Double:
          this.Write((double)value.Value);
          break;

        case TagType.ByteArray:
          this.Write((byte[])value.Value);
          break;

        case TagType.String:
          this.Write((string)value.Value);
          break;

        case TagType.List:
          this.Write((TagCollection)value.Value);
          break;

        case TagType.Compound:
          this.Write((TagDictionary)value.Value);
          break;

        case TagType.IntArray:
          this.Write((int[])value.Value);
          break;

        default:
          throw new ArgumentException("Unrecognized or unsupported tag type.", "value");
      }
    }

 public void SaveCommit( ITag tag, out bool success )
 {
     using ( IUnitOfWork u = UnitOfWork.Begin() ) {
         Save( tag, out success );
         if ( success )
             u.Commit();
     }
 }

 public static PostEntity ToPostEntity(this PostViewModel postViewModel, ITag tagRepository)
 {
     var postEntity = postViewModel.Post;
     postEntity.Categories = GetSelectedCategories(postViewModel.Categories);
     if (!string.IsNullOrEmpty(postViewModel.Tags))
         postEntity.Tags = GetSelectedTags(postViewModel.Tags, tagRepository);
     return postEntity;
 }

 public BasicFilter(string name, ITag tag, IOperator filterOperator, string criteria)
     : base(name)
 {
     _tag = tag;
       _operator = filterOperator;
       _tag.attachObserver(this);
       this._criteria = criteria;
 }

		public FourthGenResourceLayoutTable(ITag playTag, FileSegmentGroup metaArea, MetaAllocator allocator,
			EngineDescription buildInfo)
		{
			_tag = playTag;
			_metaArea = metaArea;
			_allocator = allocator;
			_buildInfo = buildInfo;
		}

 public Post(IUser userRepository, ICategory categoryRepository, ITag tagRepository, IComment commentRepository)
 {
     _postsTable = context.GetTable<PostEntity>();
     _commentRepository = commentRepository;
     _tagRepository = tagRepository;
     _categoryRepository = categoryRepository;
     _userRepository = userRepository;
 }

 internal EditBasicFilter(BasicFilter target, string newName, ITag newTag, IOperator newOperator, string newCriteria)
 {
     _newName = newName;
       _newTag = newTag;
       _newCriteria = newCriteria;
       _target = target;
       _newOperator = newOperator;
 }

 public CreativeController(ITag tag, ICreative creative, IChapter chapter, IUser user, ILike like)
 {
     this.tagRepository = tag;
     this.creativeRepository = creative;
     this.chapterRepository = chapter;
     this.userRepository = user;
     this.likeRepository = like;
 }

 public HomeController(IPost postRepository, IUser userRepository, ICategory categoryRepository, ITag tagRepository, ISettings settingsRepository, ICacheService cacheService)
     : base (settingsRepository)
 {
     _postRepository = postRepository;
     _userRepository = userRepository;
     _categoryRepository = categoryRepository;
     _tagRepository = tagRepository;
     _cacheService = cacheService;
 }

        public ExternalEditMarker? TryCreateExternalEditMarker(ITag tag, SnapshotSpan tagSpan)
        {
            if (IsVsAdornmentTagType(tag.GetType()) && IsEditTag(tag))
            {
                return  new ExternalEditMarker(ExternalEditKind.Resharper, tagSpan);
            }

            return null;
        }

        public void Delete( ITag tag )
        {
            Checks.Argument.IsNotNull( tag, "tag" );

            using ( IUnitOfWork u = UnitOfWork.Begin() ) {
                _repo.Remove( tag );
                u.Commit();
            }
        }

    protected virtual object ReadTagValue(ITag tag)
    {
      object result;

      switch (tag.Type)
      {
        case TagType.Byte:
          result = this.ReadByte();
          break;

        case TagType.Short:
          result = this.ReadShort();
          break;

        case TagType.Int:
          result = this.ReadInt();
          break;

        case TagType.Long:
          result = this.ReadLong();
          break;

        case TagType.Float:
          result = this.ReadFloat();
          break;

        case TagType.Double:
          result = this.ReadDouble();
          break;

        case TagType.ByteArray:
          result = this.ReadByteArray();
          break;

        case TagType.String:
          result = this.ReadString();
          break;

        case TagType.List:
          result = this.ReadCollection((TagList)tag);
          break;

        case TagType.Compound:
          result = this.ReadDictionary((TagCompound)tag);
          break;

        case TagType.IntArray:
          result = this.ReadIntArray();
          break;

        default:
          throw new InvalidDataException($"Unrecognized tag type: {tag.Type}");
      }

      return result;
    }

        public void AddTag(ITag tag)
        {
            if (tag == null)
                throw new ArgumentNullException("tag");

            if (tags.Contains(tag))
                return;

            tags.Add(tag);
        }