/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c>; a list of unique <c>author</c>
/// <c>claimed-author</c>'s, and <c>work</c>'s (all filtered, with digits).
/// </returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder =
new DataPinBuilder(DataPinHelper.DefaultFilter);
builder.Set("tot", Contents?.Count ?? 0, false);
if (Contents?.Count > 0)
{
foreach (MsContent content in Contents)
{
builder.AddValue("author", content.Author,
filter: true, filterOptions: true);
if (!string.IsNullOrEmpty(content.ClaimedAuthor))
{
builder.AddValue("claimed-author", content.ClaimedAuthor,
filter: true, filterOptions: true);
}
builder.AddValue("work", content.Work,
filter: true, filterOptions: true);
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>fr.tag</c>=tag if any.</returns>
public IEnumerable <DataPin> GetDataPins(IItem item = null)
{
DataPinBuilder builder = new DataPinBuilder(
new StandardDataPinTextFilter());
// fr.tot-count
builder.Set(PartBase.FR_PREFIX + "tot", Forms?.Count ?? 0, false);
if (Forms?.Count > 0)
{
foreach (LingTaggedForm form in Forms)
{
// fr.lemma
if (form.Lemmata?.Count > 0)
{
builder.AddValues(PartBase.FR_PREFIX + "lemma",
form.Lemmata,
filter: true,
filterOptions: true);
}
// fr.tag
if (form.Tags?.Count > 0)
{
builder.AddValues(PartBase.FR_PREFIX + "tag",
form.Tags.Select(t => t.Value));
}
}
}
return(builder.Build(null));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
if (Subjects?.Count > 0)
{
builder.AddValues("subject", Subjects);
}
if (Date != null)
{
builder.AddValue("date-value", Date.GetSortValue());
}
if (!string.IsNullOrEmpty(Color))
{
builder.AddValue("color", Color, filter: true, filterOptions: true);
}
if (Links?.Count > 0)
{
builder.AddValues("target-id", Links.Select(l => l.Id));
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c>, <c>dubious-count</c>,
/// <c>lost-count</c>, and a list with <c>title</c> (filtered, with
/// digits), <c>genre</c>, <c>language</c>.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
// tot-count
builder.Set("tot", Works?.Count ?? 0, false);
// dubious-count
builder.Set("dubious", Works?.Count(w => w.IsDubious) ?? 0, false);
// lost-count
builder.Set("lost", Works?.Count(w => w.IsLost) ?? 0, false);
if (Works?.Count > 0)
{
foreach (PersonWork work in Works)
{
// title
builder.AddValues("title", work.Titles,
filter: true, filterOptions: true);
// genre
builder.AddValue("genre", work.Genre);
// language
builder.AddValue("language", work.Language);
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c>, <c>palimpsest</c> (true if any),
/// and a collection of pins with these keys: <c>material</c>,
/// <c>sheet-count</c>, <c>guard-sheet-count</c>.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder();
builder.Set("tot", Units?.Count ?? 0, false);
if (Units?.Count > 0)
{
bool pal = false;
foreach (MsUnit unit in Units)
{
if (!pal && unit.Palimpsests?.Count > 0)
{
pal = true;
}
builder.AddValue("material", unit.Material);
if (unit.SheetCount > 0)
{
builder.AddValue("sheet-count", unit.SheetCount);
}
if (unit.GuardSheetCount > 0)
{
builder.AddValue("guard-sheet-count", unit.GuardSheetCount);
}
}
builder.AddValue("palimpsest", pal);
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: collections of unique values keyed under these
/// IDs: <c>title</c> (filtered, including digits) and <c>date-value</c>,
/// plus a list of participant IDs in <c>pid</c>.
/// </returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
builder.Set("tot", Dedications?.Count ?? 0, false);
foreach (LitDedication dedication in Dedications)
{
builder.AddValue("title",
dedication.Title, filter: true, filterOptions: true);
if (dedication.Date != null)
{
builder.AddValue("date-value", dedication.Date.GetSortValue());
}
if (dedication.Participants?.Count > 0)
{
builder.AddValues("pid",
dedication.Participants.Select(p => p.Id));
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c>, and lists of pins with keys:
/// <c>tag-TAG-count</c>, <c>library</c> (filtered, with digits),
/// <c>city</c> (filtered).
/// </returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
builder.Set("tot", Signatures?.Count ?? 0, false);
if (Signatures?.Count > 0)
{
foreach (MsSignature signature in Signatures)
{
builder.Increase(signature.Tag, false, "tag-");
if (!string.IsNullOrEmpty(signature.Library))
{
builder.AddValue("library",
signature.Library, filter: true, filterOptions: true);
}
if (!string.IsNullOrEmpty(signature.City))
{
builder.AddValue("city", signature.City, filter: true);
}
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>fr.tag</c>=tag if any.</returns>
public IEnumerable <DataPin> GetDataPins(IItem item = null)
{
DataPinBuilder builder = new DataPinBuilder(
new StandardDataPinTextFilter());
// fr-tot-count
builder.Set(PartBase.FR_PREFIX + "tot",
Interpolations?.Count ?? 0, false);
if (Interpolations?.Count > 0)
{
foreach (Interpolation entry in Interpolations)
{
// fr-language
if (entry.Languages?.Length > 0)
{
builder.AddValues(PartBase.FR_PREFIX + "language",
entry.Languages);
}
// fr-value
builder.AddValue(PartBase.FR_PREFIX + "value", entry.Value,
filter: true);
// fr-tag
builder.AddValue(PartBase.FR_PREFIX + "tag", entry.Tag);
// fr-role
builder.AddValue(PartBase.FR_PREFIX + "role", entry.Role);
}
}
return(builder.Build(null));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c> and a collection of pins with
/// these keys: <c>role</c>, <c>language</c>, <c>type</c>,
/// <c>hand-id</c>.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder();
builder.Set("tot", Scripts?.Count ?? 0, false);
if (Scripts?.Count > 0)
{
foreach (MsScript script in Scripts)
{
builder.AddValue("role", script.Role);
if (script.Languages?.Count > 0)
{
builder.AddValues("language", script.Languages);
}
builder.AddValue("type", script.Type);
if (script.Hands?.Count > 0)
{
builder.AddValues("hand-id", script.Hands.Select(h => h.Id));
}
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c>, and a collection of pins with
/// keys: <c>subject-X-count</c>, <c>place</c> (filtered, with digits),
/// <c>date-value</c>.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
builder.Set("tot", Watermarks?.Count ?? 0, false);
if (Watermarks?.Count > 0)
{
foreach (MsWatermark watermark in Watermarks)
{
builder.Increase(watermark.Subject, false, "subject-");
if (!string.IsNullOrEmpty(watermark.Place))
{
builder.AddValue("place",
watermark.Place, filter: true, filterOptions: true);
}
if (watermark.Date != null)
{
builder.AddValue("date-value", watermark.Date.GetSortValue());
}
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
new StandardDataPinTextFilter());
builder.AddValue("id", GraffitiId);
if (!string.IsNullOrEmpty(Language))
{
builder.AddValue("language", Language);
}
if (!string.IsNullOrEmpty(Verse))
{
builder.AddValue("verse", Verse);
}
if (!string.IsNullOrEmpty(Author))
{
builder.AddValue("author", Author, filter: true, filterOptions: true);
}
if (Identifications?.Count > 0)
{
builder.AddValues("pid", Identifications.Select(i => i.Id));
}
if (Date != null)
{
builder.AddValue("date-value", Date.GetSortValue());
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c> and a collection of pins with
/// these keys: <c>lid</c>, <c>lemma</c>, <c>u-lemma</c>, <c>pos</c>,
/// <c>variant</c>, <c>u-variant</c>.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
builder.Set("tot", Forms?.Count ?? 0, false);
if (Forms?.Count > 0)
{
foreach (WordForm form in Forms)
{
builder.AddValue("lid", form.Lid);
builder.AddValue("lemma", form.Lemma,
filter: true, filterOptions: true);
builder.AddValue("u-lemma", form.Lemma);
builder.AddValue("pos", form.Pos);
if (form.Variants?.Count > 0)
{
foreach (var v in form.Variants)
{
builder.AddValue("variant", v.Value,
filter: true, filterOptions: true);
builder.AddValue("u-variant", v.Value);
}
}
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c> and a collection of pins with
/// these keys: <c>id</c>.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder();
builder.Set("tot", Hands?.Count ?? 0, false);
if (Hands?.Count > 0)
{
foreach (MsHand hand in Hands)
{
if (!string.IsNullOrEmpty(hand.Id))
{
builder.AddValue("id", hand.Id);
}
if (!string.IsNullOrEmpty(hand.PersonId))
{
builder.AddValue("person-id", hand.PersonId);
}
if (hand.Types?.Count > 0)
{
foreach (string type in hand.Types)
{
builder.AddValue("type", type);
}
}
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: a collection of pins with keys:
/// <c>tot-count</c>=total count of exchanges in the part;
/// <c>dubious-count</c>, <c>indirect-count</c>, <c>incoming-count</c>,
/// <c>{TAG}-date-value</c>, <c>{TAG}-place</c> (filtered, including
/// digits), <c>participant.ROLE</c> (filtered including digits),
/// <c>att-TYPE-count</c>=count of attachment of type TYPE (one count
/// for each distinct type found in the part), <c>att-tot-count</c>=
/// total count of attachments.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder =
new DataPinBuilder(DataPinHelper.DefaultFilter);
builder.Set("tot", Exchanges?.Count ?? 0, false);
foreach (CorrExchange exchange in Exchanges)
{
if (exchange.IsDubious)
{
builder.Increase("dubious", false);
}
if (exchange.IsIndirect)
{
builder.Increase("indirect", false);
}
if (exchange.IsFromParticipant)
{
builder.Increase("incoming", false);
}
if (exchange.Chronotopes?.Count > 0)
{
foreach (Chronotope c in exchange.Chronotopes)
{
string tag = c.Tag?.ToLowerInvariant() ?? "";
if (c.Date != null)
{
builder.AddValue("date-value." + tag, c.Date.GetSortValue());
}
if (!string.IsNullOrEmpty(c.Place))
{
builder.AddValue("place." + tag,
c.Place, filter: true, filterOptions: true);
}
}
}
if (exchange.Participants?.Count > 0)
{
foreach (var p in exchange.Participants)
{
builder.AddValue($"participant.{p.Tag ?? ""}", p.Id,
filter: true, filterOptions: true);
}
}
if (exchange.Attachments?.Count > 0)
{
builder.Increase(from a in exchange.Attachments
select a.Type, true, "att-");
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
builder.AddValue("prison-id", PrisonId);
builder.AddValue("cell", Cell);
builder.AddValue("loc", Location);
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
builder.AddValue("id", PrisonerId);
builder.AddValue("prison-id", PrisonId);
if (Sex != '\0')
{
builder.AddValue("sex", new string(Sex, 1));
}
if (Name != null)
{
builder.AddValue("name",
DataPinHelper.DefaultFilter.Apply(Name.GetFullName(), true));
}
if (BirthDate != null)
{
builder.AddValue("birth-value", BirthDate.GetSortValue());
}
if (DeathDate != null)
{
builder.AddValue("death-value", DeathDate.GetSortValue());
}
if (!string.IsNullOrEmpty(Origin))
{
builder.AddValue("origin", Origin, filter: true, filterOptions: true);
}
if (!string.IsNullOrEmpty(Charge))
{
builder.AddValue("charge", Charge, filter: true, filterOptions: true);
}
if (!string.IsNullOrEmpty(Judgement))
{
builder.AddValue("judgement", Judgement, filter: true, filterOptions: true);
}
if (DetentionStart != null)
{
builder.AddValue("det-start-value", DetentionStart.GetSortValue());
}
if (DetentionEnd != null)
{
builder.AddValue("det-end-value", DetentionEnd.GetSortValue());
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>fr.tag</c>=tag if any.</returns>
public IEnumerable <DataPin> GetDataPins(IItem item = null)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
builder.AddValue(PartBase.FR_PREFIX + "value",
Value, filter: true, filterOptions: true);
builder.AddValue(PartBase.FR_PREFIX + "u-value", Value);
builder.AddValue(PartBase.FR_PREFIX + "n-value", NormValue);
return(builder.Build(null));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
builder.AddValue("id", PrisonId);
if (!string.IsNullOrEmpty(Place))
{
builder.AddValue("place", Place, filter: true, filterOptions: true);
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c> and a collection of pins with
/// these keys: <c>witness</c>.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder();
builder.Set("tot", Witnesses?.Count ?? 0, false);
if (Witnesses?.Count > 0)
{
builder.AddValues("witness", from w in Witnesses select w.Id);
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>sheet-count</c>, <c>guard-sheet-count</c>,
/// <c>section-count</c>, and a list with keys: <c>section-TAG-count</c>,
/// <c>section-label</c> (filtered, with digits),
/// <c>section-date-value</c>, <c>guard-material</c> (filtered, with
/// digits), <c>guard-date-value</c>.
/// </returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder =
new DataPinBuilder(DataPinHelper.DefaultFilter);
builder.Set("sheet", SheetCount, false);
builder.Set("guard-sheet", GuardSheetCount, false);
builder.Set("section", Sections?.Count ?? 0, false);
if (GuardSheets?.Count > 0)
{
foreach (MsGuardSheet guard in GuardSheets)
{
if (!string.IsNullOrEmpty(guard.Material))
{
builder.AddValue("guard-material", guard.Material,
filter: true, filterOptions: true);
}
if (guard.Date != null)
{
builder.AddValue("guard-date-value",
guard.Date.GetSortValue());
}
}
}
if (Sections?.Count > 0)
{
foreach (MsSection section in Sections)
{
builder.Increase(section.Tag, false, "section-");
if (!string.IsNullOrEmpty(section.Label))
{
builder.AddValue("section-label",
section.Label, filter: true, filterOptions: true);
}
if (section.Date != null)
{
builder.AddValue("section-date-value",
section.Date.GetSortValue());
}
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>att-TYPE-count</c>=count of attachment of
/// type TYPE (one count for each distinct type found in the part),
/// <c>tot-count</c>=total count of attachments; plus a list of
/// attachment IDs with key <c>aid</c>.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder();
builder.Set("tot", Attachments?.Count ?? 0, false);
if (Attachments.Count > 0)
{
builder.AddValues("aid", Attachments.Select(a => a.Id));
builder.Increase(from a in Attachments
select a.Type, false, "att-");
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c> and a collection of pins with
/// these keys: <c>hand-id</c>.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder();
builder.Set("tot", Features?.Count ?? 0, false);
if (Features?.Count > 0)
{
foreach (MsFormalFeature feature in Features)
{
builder.AddValue("hand-id", feature.HandId);
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c> and a collection of pins with
/// these keys: <c>type-{TYPE}-count</c>.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder();
builder.Set("tot", Ornaments?.Count ?? 0, false);
if (Ornaments?.Count > 0)
{
foreach (MsOrnament ornament in Ornaments)
{
// type-X-count counts if not null, unfiltered:
builder.Increase(ornament.Type, false, "type-");
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c> and a collection of pins with
/// these keys: <c>type-X-count</c>, <c>subject-X-count</c>,
/// <c>color-X-count</c>, (all the keys with X are filtered, with digits),
/// <c>artist-id</c> (filtered, with digits).
/// </returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
builder.Set("tot", Decorations?.Count ?? 0, false);
if (Decorations?.Count > 0)
{
foreach (MsDecoration decoration in Decorations)
{
builder.Increase(
DataPinHelper.DefaultFilter.Apply(decoration.Type, true),
false, "type-");
if (decoration.Date != null)
{
builder.AddValue("date-value", decoration.Date.GetSortValue());
}
foreach (MsDecorationElement element in decoration?.Elements)
{
builder.Increase(
DataPinHelper.DefaultFilter.Apply(element.Subject, true),
false,
"subject-");
foreach (string color in element.Colors)
{
builder.Increase(
DataPinHelper.DefaultFilter.Apply(color, true),
false,
"color-");
}
}
if (!string.IsNullOrEmpty(decoration.Artist?.Id))
{
builder.AddValue("artist-id", decoration.Artist.Id,
filter: true, filterOptions: true);
}
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c> and a collection of pins with
/// keys: <c>pos-X-count</c>, <c>vrt-X-count</c>.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder();
builder.Set("tot", Catchwords?.Count ?? 0, false);
if (Catchwords?.Count > 0)
{
foreach (MsCatchword catchword in Catchwords)
{
builder.Increase(catchword.Position, false, "pos-");
builder.Increase(catchword.IsVertical, false, "vrt-");
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>person-id</c>; <c>job</c> (filtered, with digits).
/// </returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
if (!string.IsNullOrEmpty(PersonId))
{
builder.AddValue("person-id", PersonId);
}
if (!string.IsNullOrEmpty(Job))
{
builder.AddValue("job", Job, filter: true, filterOptions: true);
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: multiple pins with key <c>area</c>,
/// <c>owner</c> (both filtered, with digits).</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
new StandardDataPinTextFilter());
if (Provenances?.Count > 0)
{
builder.AddValues("area", Provenances.Select(p => p.Area),
filter: true, filterOptions: true);
}
if (Owners?.Count > 0)
{
builder.AddValues("owner", Owners,
filter: true, filterOptions: true);
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c>=total count of pseudonyms;
/// for each pseudonym, a <c>pseudonym</c> pin with value equal to
/// <c>+</c>=author's pseudonym or <c>-</c>=non-author pseudonym,
/// followed by the filtered pseudonym (including digits).
/// </returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
DataPinHelper.DefaultFilter);
builder.Set("tot", Pseudonyms?.Count ?? 0, false);
if (Pseudonyms?.Count > 0)
{
builder.AddValues("pseudonym",
from p in Pseudonyms
select builder.ApplyFilter(options: true,
p.IsAuthor ? "+" : "-",
true,
p.Value));
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder(
new StandardDataPinTextFilter());
// tot-count
builder.Set("tot", Contents?.Count ?? 0, false);
if (Contents?.Count > 0)
{
foreach (var content in Contents)
{
builder.AddValue("work", content.Work);
builder.AddValue("title", content.Title,
filter: true, filterOptions: true);
}
}
return(builder.Build(this));
}
/// <summary>
/// Get all the key=value pairs (pins) exposed by the implementor.
/// </summary>
/// <param name="item">The optional item. The item with its parts
/// can optionally be passed to this method for those parts requiring
/// to access further data.</param>
/// <returns>The pins: <c>tot-count</c> and a collection of pins with
/// these keys: <c>sheet-count</c>.</returns>
public override IEnumerable <DataPin> GetDataPins(IItem item)
{
DataPinBuilder builder = new DataPinBuilder();
builder.Set("tot", Quires?.Count ?? 0, false);
if (Types?.Count > 0)
{
builder.AddValues("type", Types);
}
if (Quires?.Count > 0)
{
builder.AddValues(
"sheet-count",
from q in Quires
select q.SheetCount.ToString(CultureInfo.InvariantCulture));
}
return(builder.Build(this));
}