public Tag(ITaggable target, TagPrototype prototype)
{
if (prototype.TargetType != target.GetType())
throw new ArgumentException("The given prototype is not compatible with the given target's type.",
"prototype");
Target = target;
Prototype = prototype;
}
static void Tags(ITaggable t)
{
if (t.Tags.Count > 0)
{
Console.Write("Tags: ");
Console.WriteLine(t.Tags.Aggregate((a, b) => $"{a}, {b}"));
}
//for (int i = 0; i < tags.Count - 1; i++)
// Console.Write($" {tags[i]},");
//Console.WriteLine(" " + tags[tags.Count - 1]);
}
public static void EnsureTags(IDbContext dbContext, ITaggable taggable, params Tag[] tags)
{
if (tags == null)
{
return;
}
foreach (Tag tag in tags)
{
EnsureTag(dbContext, taggable, tag);
}
}
protected static void SetTags(ParsedMessage parsedMessage, ITaggable taggable)
{
if (parsedMessage["TAGS"] == null)
{
return;
}
taggable.Tags.Clear();
foreach (var tag in parsedMessage["TAGS"].Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
{
taggable.Tags.Add(tag);
}
}
public IList<Tag> GetByItem(ITaggable item)
{
var id = item.Id;
var typeName = item.GetType().AssemblyQualifiedName;
DetachedCriteria query =
DetachedCriteria.For(typeof(Tag), "t").
CreateCriteria("Prototype", "p", JoinType.InnerJoin);
ICriteria criteriaQuery = query.GetExecutableCriteria(_session);
criteriaQuery.Add(Restrictions.Eq("p.TargetTypeName", typeName));
criteriaQuery.Add(Restrictions.Eq("t.TargetId", id));
return criteriaQuery.List<Tag>();
}
public static void EnsureTag(Tag[] allTags, ITaggable taggable, Tag tag)
{
// we change taggable (e.g. Link) but do not call dbContext.Update as this is done
// by caller. this way we can prevent Modified-property on taggable being updated,
// just because TagString changed (e.g. when tag hierarchy has changed). if we add
// a tag to a taggable, dbContext.Update should be called by caller, as he is actually
// changing the taggable.
string currentTagString = taggable.TagString ?? string.Empty;
bool hasTags = !string.IsNullOrEmpty(currentTagString);
string tagPath = GetTagPath(allTags, tag);
if (hasTags && currentTagString.Contains(tagPath))
{
return;
}
taggable.TagString = hasTags
? string.Concat(currentTagString, Separator, tagPath)
: tagPath;
}
private static int CountInheritedTags(ITaggable[] taggables, int tagId)
{
string tagIdSegment = JoinTagPathElements(tagId);
return taggables.Count(t => IsInheritedTag(t, tagIdSegment));
}
public static bool HasTag(this ITaggable taggable, string tag)
{
Ensure.That(taggable, nameof(taggable)).IsNotNull();
return(taggable.Tags.Contains(tag));
}
public void DeleteTagFromTaggable(Tag tag, ITaggable taggable)
{
if (taggable is Answer)
{
DeleteTagFromAnswer(taggable as Answer, tag);
}
else if (taggable is Question)
{
DeleteTagFromQuestion(taggable as Question, tag);
}
else if (taggable is Assessment)
{
DeleteTagFromAssessment(taggable as Assessment, tag);
}
else
{
throw new Exception("Cannot delete unsupported ITaggable object.");
}
}
public static Expect <Tag <T> > IsSet <T>(this Expect <Tag <T> > expect, ITaggable target, Text issue = null)
{
return(expect.IsTrue(t => Check.True(t).IsSet(target), issue, "tag set", t => $"tag set: {t}"));
}
static void Main(string[] args)
{
// Pergunta 2
PowerUp armorPack = new PowerUp();
armorPack.Tag = "CRL";
Console.WriteLine(armorPack);
armorPack.Tag = "Armor+75";
Console.WriteLine(armorPack);
// Instrução 1
// Esta instrução é válida, pois o construtor da classe PowerUp não
// requer qualquer argumento e não possui modificadores de herança;
PowerUp pu = new PowerUp();
// Instrução 2
// Esta instrução é inválida, pois a classe GameObject com o
// modificador de herança abstract, impedindo-a de ser instanciada;
GameObject go = new GameObject();
// Instrução 3
// Esta instrução é válida, pois, tal como a instrução 1, o
// construtor da classe Trap não requer qualquer argumento e não
// possui modificadores de herança;
Trap t = new Trap();
// Instrução 4
// Esta instrução é inválida, pois não é possível instanciar uma
// interface;
ITaggable it = new ITaggable();
// Instrução 5
// Instrução 5: Esta instrução é inválida, pois a classe
// GameObject não possui o método `DisableTrap()`, apenas a classe
// Trap;
go.DisableTrap(); // go é uma variável do tipo GameObject
// Instrução 6
// Esta instrução é inválida, pois, tal como a instrução 2, a
// declaração da classe `GameObject` tem o modificador de herança
// `abstract`, impedindo-a de ser instanciada;
PowerUp armorPacko = new GameObject();
// Instrução 7
// Esta instrução é inválida, pois tenta converter o método
// DisableTrap() da classe Trap para tipo inteiro, o que é
// impossível;
Trap gobj = new Trap();
int p = gobj.DisableTrap; // gobj é do tipo Trap
//Instrução 8
// Esta instrução é inválida, pois a interface ITaggable não é
// implementada na classe Trap, logo uma instância desta classe não
// pode ter uma tag como variável;
Trap trap = new Trap();
Console.WriteLine($"{trap.Tag}"); // trap é uma instância de Trap
// Instrução 9
// Esta instrução é válida, pois a classe Trap é uma subclasse da
// classe GameObject, que é a superclasse, logo podemos ter uma
// instância da classe Trap do tipo GameObject, mas não o contrário
// como podemos observar nas instruções 2 e 6;
GameObject go2 = new Trap();
// Instrução 10
// Esta instrução é válida, pois, tal como na instrução 9, a classe
// PowerUp é uma subclasse da classe GameObject, que é a
// superclasse, logo podemos ter uma instância da classe PowerUp do
// tipo GameObject, mas não o contrário como podemos observar nas
// instruções 2 e 6;
GameObject go3 = new PowerUp();
// Instrução 11
// Esta instrução é válida, pois a classe PowerUp tem o método
// Priority, herdado da superclasse GameObject e sobreposto
// para retornar o valor do comprimento da Tag, podendo usar a Tag
// pois implementa a interface ITaggable;
PowerUp pup = new PowerUp();
Console.WriteLine($"{pup.Priority()}");// pup: instância de PowerUp
}
public static void EnsureTag(IDbContext dbContext, ITaggable taggable, Tag tag)
{
EnsureTag(dbContext.Tags.ToArray(), taggable, tag);
}
private static bool IsInheritedTag(ITaggable taggable, string tagStringSegment)
{
return GetPathSegments(taggable.TagString).Any(ts => ts != tagStringSegment
&& !ts.EndsWith(tagStringSegment)
&& ts.Contains(tagStringSegment));
}
private static bool IsDirectTag(ITaggable taggable, string tagStringSegment)
{
return GetPathSegments(taggable.TagString).Any(ts => IsDirectTag(tagStringSegment, ts));
}
public static Check <Tag <T> > IsSet <T>(this Check <Tag <T> > check, ITaggable target)
{
return(check.IsTrue(t => t.IsSet(target)));
}
public static void RemoveTag(ITaggable taggable, int tagId)
{
if (taggable == null || string.IsNullOrEmpty(taggable.TagString))
{
return;
}
var tagStringElement = JoinTagPathElements(tagId);
taggable.TagString = string.Join(Separator.ToString(),
GetPathSegments(taggable.TagString).Where(s => !s.Contains(tagStringElement)));
}
public void Clear(ITaggable target)
{
target.Tags.Clear(this);
}
public void Set(ITaggable target, object value)
{
target.Tags.Set(this, value);
}
public object Get(ITaggable target, bool throwIfUnset = false)
{
return(target.Tags.Get(this, throwIfUnset));
}
public bool IsSet(ITaggable target)
{
return(target.Tags.IsSet(this));
}
