public override void Write(Utf8JsonWriter writer, AnonymousResourceCollection value, JsonSerializerOptions options)
{
var tracked = new TrackedResources();
writer.WriteStartObject();
writer.WritePropertyName(JsonApiMembers.DataEncoded);
WriteWrapped(writer, ref tracked, value, options);
if (tracked.Count > 0)
{
writer.WritePropertyName(JsonApiMembers.IncludedEncoded);
writer.WriteStartArray();
var index = 0;
while (index < tracked.Count)
{
var included = tracked.Get(index);
included.Converter.Write(writer, ref tracked, included.Value, options);
index++;
}
writer.WriteEndArray();
}
writer.WriteEndObject();
}
public override void WriteWrapped(Utf8JsonWriter writer, ref TrackedResources tracked, AnonymousResourceCollection container, JsonSerializerOptions options)
{
var value = container.Value;
if (value == null)
{
writer.WriteNullValue();
}
else if (value is IEnumerable collection)
{
var converter = GetWrappedConverter(options);
writer.WriteStartArray();
foreach (var element in collection)
{
converter.WriteWrapped(writer, ref tracked, new AnonymousResource(element), options);
}
writer.WriteEndArray();
}
else
{
throw new JsonApiFormatException($"JSON:API resources collection of type '{value.GetType()}' must be an enumerable");
}
}
private void RemoveItemsFromTracker(StorageContainer sc, TechType item, int amountToRemove = 1)
{
if (IsBeingDeleted == true)
{
return;
}
if (TrackedResources.ContainsKey(item))
{
TrackedResource trackedResource = TrackedResources[item];
int newAmount = trackedResource.Amount - amountToRemove;
trackedResource.Amount = newAmount;
if (newAmount <= 0)
{
TrackedResources.Remove(item);
}
else
{
int amountLeftInContainer = sc.container.GetCount(item);
if (amountLeftInContainer <= 0)
{
trackedResource.Containers.Remove(sc);
}
}
rmd?.ItemModified(item, newAmount);
}
}
private void AddItemsToTracker(StorageContainer sc, TechType item, int amountToAdd = 1)
{
if (IsBeingDeleted == true)
{
return;
}
if (DONT_TRACK_GAMEOBJECTS.Contains(item.AsString().ToLower()))
{
return;
}
if (TrackedResources.ContainsKey(item))
{
TrackedResources[item].Amount = TrackedResources[item].Amount + amountToAdd;
TrackedResources[item].Containers.Add(sc);
}
else
{
TrackedResources.Add(item, new TrackedResource()
{
TechType = item,
Amount = amountToAdd,
Containers = new HashSet <StorageContainer>()
{
sc
}
});
}
rmd?.ItemModified(item, TrackedResources[item].Amount);
}
protected override void WriteErrors(Utf8JsonWriter writer, ref TrackedResources tracked, JsonApiDocument value, JsonSerializerOptions options)
{
if (value.Errors != null)
{
writer.WritePropertyName(JsonApiMembers.ErrorsEncoded);
WriteWrapped(writer, ref tracked, value.Errors, options);
}
}
protected TConverter?ReadWrapped <TConverter>(ref Utf8JsonReader reader, ref TrackedResources tracked, JsonSerializerOptions options)
{
if (options.GetConverter(typeof(TConverter)) is not WrappedJsonConverter <TConverter> converter)
{
throw new JsonApiException($"Could not find converter for type '{typeof(TConverter)}'");
}
return(converter.ReadWrapped(ref reader, ref tracked, default, options));
private void WriteRelationships(Utf8JsonWriter writer, JsonTypeInfo info, ref TrackedResources tracked, object value)
{
var relationshipsWritten = false;
foreach (var member in info.AttributeMembers)
{
if (member.IsRelationship)
{
member.WriteRelationship(writer, ref tracked, value, ref relationshipsWritten);
}
}
for (var i = 0; i < tracked.Relationships.Count; i++)
{
var relationship = tracked.Relationships.Get(i);
if (!relationshipsWritten)
{
writer.WritePropertyName(JsonApiMembers.RelationshipsEncoded);
writer.WriteStartObject();
relationshipsWritten = true;
}
writer.WritePropertyName(relationship.Name);
writer.WriteStartObject();
writer.WritePropertyName(JsonApiMembers.DataEncoded);
writer.WriteStartArray();
for (var j = 0; j < tracked.Count; j++)
{
var included = tracked.Get(j);
if (included.IsUnwritten() && included.RelationshipId == relationship.Id)
{
writer.WriteStartObject();
writer.WriteString(JsonApiMembers.IdEncoded, included.Identifier.Id);
writer.WriteString(JsonApiMembers.TypeEncoded, included.Identifier.Type);
writer.WriteEndObject();
}
}
writer.WriteEndArray();
writer.WriteEndObject();
}
if (relationshipsWritten)
{
writer.WriteEndObject();
}
tracked.Relationships.Clear();
}
private void AddEmptyTrackedObject(ResourceIdentifier identifier, ref TrackedResources tracked)
{
var id = identifier.Id;
var type = identifier.Type;
var idString = id.GetString();
var typeString = type.GetString();
tracked.SetIncluded(identifier, idString, typeString, EmptyJsonObjectConverter.Default, null !);
}
public override RelationshipResource <T> Read(ref Utf8JsonReader reader, ref TrackedResources tracked, JsonSerializerOptions options)
{
var state = reader.ReadRelationship();
EnsureTypeInfo(options);
var resource = info !.Creator();
if (resource == null)
{
return(default);
protected override void WriteData(Utf8JsonWriter writer, ref TrackedResources tracked, JsonApiDocument value, JsonSerializerOptions options)
{
if (value.Errors == null && value.Meta == null && value.Data == null)
{
writer.WriteNull(JsonApiMembers.DataEncoded);
}
else if (value.Data != null)
{
writer.WritePropertyName(JsonApiMembers.DataEncoded);
JsonSerializer.Serialize(writer, value.Data, options);
}
}
public override RelationshipResource <T> Read(ref Utf8JsonReader reader, ref TrackedResources tracked, JsonSerializerOptions options)
{
var relationship = default(RelationshipResource <T>);
var state = reader.ReadRelationship();
while (reader.IsInObject())
{
var name = reader.ReadMember(ref state);
if (name == RelationshipFlags.Data)
{
relationship = ReadWrapped(ref reader, ref tracked, default, options);
public override T?Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
var errors = default(T);
var state = reader.ReadDocument();
var tracked = new TrackedResources();
while (reader.IsInObject())
{
var name = reader.ReadMember(ref state);
if (name == DocumentFlags.Errors)
{
errors = ReadWrapped(ref reader, ref tracked, default, options);
public override T?Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
var resource = default(T);
var state = reader.ReadDocument();
var tracked = new TrackedResources();
Utf8JsonReader savedReader = default;
var includedReadFirst = false;
while (reader.IsInObject())
{
var name = reader.ReadMember(ref state);
if (name == DocumentFlags.Data)
{
resource = ReadWrapped(ref reader, ref tracked, default, options);
private void WriteAttributes(Utf8JsonWriter writer, JsonTypeInfo info, ref TrackedResources tracked, object value)
{
var attributesWritten = false;
foreach (var member in info.AttributeMembers)
{
var memberName = attributesWritten
? default
: JsonApiMembers.AttributesEncoded;
attributesWritten |= member.Write(writer, ref tracked, value, memberName);
}
if (attributesWritten)
{
writer.WriteEndObject();
}
}
public override void ReadRelationship(ref Utf8JsonReader reader, ref TrackedResources tracked, object resource)
{
var state = reader.ReadRelationship();
while (reader.IsInObject())
{
var name = reader.ReadMember(ref state);
if (name == RelationshipFlags.Data)
{
if (reader.IsObject())
{
var identifier = reader.ReadResourceIdentifier();
AddEmptyTrackedObject(identifier, ref tracked);
}
else if (reader.IsArray())
{
reader.ReadArray(JsonApiArrayCode.Relationships);
while (reader.IsInArray())
{
var identifier = reader.ReadResourceIdentifier();
AddEmptyTrackedObject(identifier, ref tracked);
reader.Read();
}
}
else if (reader.TokenType != JsonTokenType.Null)
{
throw new JsonApiFormatException("Expected null, empty array, or resource linkage for relationship");
}
}
else
{
reader.Skip();
}
reader.Read();
}
state.Validate();
}
public void AttemptToTakeItem(TechType item)
{
if (IsBeingDeleted == true)
{
return;
}
if (timerTillNextPickup > 0f)
{
return;
}
if (TrackedResources.ContainsKey(item))
{
TrackedResource trackedResource = TrackedResources[item];
int beforeRemoveAmount = trackedResource.Amount;
if (trackedResource.Containers.Count >= 1)
{
StorageContainer sc = trackedResource.Containers.ElementAt(0);
if (sc.container.Contains(item))
{
Pickupable pickup = sc.container.RemoveItem(item);
if (pickup != null)
{
if (Inventory.main.Pickup(pickup))
{
CrafterLogic.NotifyCraftEnd(Player.main.gameObject, item);
if (beforeRemoveAmount == 1)
{
timerTillNextPickup = COOLDOWN_TIME_BETWEEN_PICKING_UP_LAST_ITEM_TYPE;
}
}
else
{
// If it fails to get added to the inventory lets add it back into the storage container.
sc.container.AddItem(pickup);
}
}
}
}
}
}
public override JsonApiError?Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
JsonApiError?firstError = null;
var state = reader.ReadDocument();
var tracked = new TrackedResources();
while (reader.IsInObject())
{
var name = reader.ReadMember(ref state);
if (name == DocumentFlags.Errors)
{
reader.ReadArray(JsonApiArrayCode.Errors);
while (reader.IsInArray())
{
if (firstError == null)
{
firstError = ReadWrapped(ref reader, ref tracked, null, options);
}
else
{
reader.Skip();
}
reader.Read();
}
}
else
{
reader.Skip();
}
reader.Read();
}
state.Validate();
return(state.HasFlag(DocumentFlags.Errors)
? firstError
: default);
protected override void WriteIncluded(Utf8JsonWriter writer, ref TrackedResources tracked, JsonApiDocument value, JsonSerializerOptions options)
{
if (value.Included != null)
{
writer.WritePropertyName(JsonApiMembers.IncludedEncoded);
writer.WriteStartArray();
foreach (var resource in value.Included)
{
if (string.IsNullOrEmpty(resource.Id) || string.IsNullOrEmpty(resource.Type))
{
throw new JsonApiFormatException("JSON:API included resource must contain both 'id' and 'type' members");
}
JsonSerializer.Serialize(writer, resource, options);
}
writer.WriteEndArray();
}
}
public override void WriteWrapped(Utf8JsonWriter writer, ref TrackedResources tracked, AnonymousResource container, JsonSerializerOptions options)
{
var value = container.Value;
if (value == null)
{
writer.WriteNullValue();
return;
}
var info = options.GetTypeInfo(value.GetType());
ValidateResource(info);
writer.WriteStartObject();
var idWritten = info.IdMember.Write(writer, ref tracked, value);
var typeWritten = info.TypeMember.Write(writer, ref tracked, value);
if (idWritten && typeWritten)
{
var id = info.IdMember.GetValue(value) as string;
var type = info.TypeMember.GetValue(value) as string;
tracked.SetEmitted(id !, type !);
}
WriteAttributes(writer, info, ref tracked, value);
WriteRelationships(writer, info, ref tracked, value);
info.LinksMember.Write(writer, ref tracked, value);
info.MetaMember.Write(writer, ref tracked, value);
writer.WriteEndObject();
}
public abstract void Write(Utf8JsonWriter writer, ref TrackedResources tracked, object value, JsonSerializerOptions options);
public abstract void Read(ref Utf8JsonReader reader, ref TrackedResources tracked, object existingValue, JsonSerializerOptions options);
public abstract T?ReadWrapped(ref Utf8JsonReader reader, ref TrackedResources tracked, T?existingValue, JsonSerializerOptions options);
public abstract void WriteWrapped(Utf8JsonWriter writer, ref TrackedResources tracked, T value, JsonSerializerOptions options);
public abstract RelationshipResource <T> Read(ref Utf8JsonReader reader, ref TrackedResources tracked, JsonSerializerOptions options);
public abstract void Write(Utf8JsonWriter writer, ref TrackedResources tracked, RelationshipResource <T> value, JsonSerializerOptions options);
public override AnonymousResourceCollection ReadWrapped(ref Utf8JsonReader reader, ref TrackedResources tracked, AnonymousResourceCollection existingValue, JsonSerializerOptions options)
{
throw new NotSupportedException();
}
public override void WriteRelationshipWrapped(Utf8JsonWriter writer, ref TrackedResources tracked, object resource)
{
}
public override void WriteRelationship(Utf8JsonWriter writer, ref TrackedResources tracked, object resource, ref bool wroteSection)
{
}
public override bool Write(Utf8JsonWriter writer, ref TrackedResources tracked, object resource, JsonEncodedText section = default)
{
return(false);
}
public override void ReadRelationshipWrapped(ref Utf8JsonReader reader, ref TrackedResources tracked, object resource)
{
reader.Skip();
}
