/// <summary>
/// Inserts an element into the List at the specified index.
/// </summary>
/// <param name="index">The zero-based index at which item should be inserted.</param>
/// <param name="element">The object to insert.</param>
public unsafe void Insert(int index, t_data_type element)
{
if (index < 0 || index > Count)
{
throw new IndexOutOfRangeException();
}
byte *targetPtr = null;
{
MODULE_CALL("PushPointerFromVariable", "$t_data_type", "\"element\"", "\"push\"");
}
int size = (int)targetPtr;
targetPtr = m_ptr;
IF("%element_fixed");
targetPtr += index * t_int;
ELSE();
for (int i = 0; i < index; i++)
{
MODULE_CALL("PushPointerThroughFieldType", "$t_data_type");
}
END();
int offset = (int)(targetPtr - m_ptr);
// InsertAndRemoveAtCodeForContainer TODO IAccessor reuse
this.m_ptr = this.ResizeFunction(this.m_ptr - sizeof(int), offset + sizeof(int), size);
*(int *)this.m_ptr += size;
this.m_ptr += sizeof(int);
targetPtr = this.m_ptr + offset;
MODULE_CALL("PushPointerFromVariable", "$t_data_type", "\"element\"", "\"assign\"");
}
/// <summary>
/// Adds an item to the end of the List
/// </summary>
/// <param name="element">The object to be added to the end of the List.</param>
public unsafe void Add(t_data_type element)
{
byte *targetPtr = null;
{
MODULE_CALL("PushPointerFromVariable", "$t_data_type", "\"element\"", "\"push\"");
}
// TODO AppendCodeForContainer IAccessor code reuse
int size = (int)targetPtr;
this.m_ptr = this.ResizeFunction(this.m_ptr - sizeof(int), *(int *)(this.m_ptr - sizeof(int)) + sizeof(int), size);
targetPtr = this.m_ptr + (*(int *)this.m_ptr) + sizeof(int);
*(int *)this.m_ptr += size;
this.m_ptr += sizeof(int);
MODULE_CALL("PushPointerFromVariable", "$t_data_type", "\"element\"", "\"assign\"");
}
public static bool ElementContainsSubstring(this t_data_type t_list, IEnumerable <string> substrings)
{
if (substrings == null || substrings.Count() == 0)
{
return(true);
}
if (t_list == null)
{
throw new ArgumentNullException("list");
}
__meta.META_VAR("std::vector<NFieldType*>*", "container_chain", "$t_substring_indexed_list_type->resolve_container_chain()");
__meta.META_VAR("std::string", "list_name", "\"list\"");
__meta.META_VAR("int", "iter_value", "0");
__meta.META("%container_chain->pop_back();");
__meta.META("%container_chain->pop_back();");
__meta.MAP_LIST("t_chain", "%container_chain");
__meta.MAP_VAR("t_list", "%list_name");
__meta.MAP_VAR("t_element", "\"sublist_\" + GetString(%iter_value)");
__meta.FOREACH();
__meta.USE_LIST("t_chain");
foreach (var t_element in t_list)
{
if (t_element == null)
{
continue;
}
__meta.META("%list_name = std::string(\"sublist_\") + GetString(%iter_value);");
__meta.META("++%iter_value;");
__meta.END();
foreach (string str in t_list)
{
if (str.Contains(substrings))
{
return(true);
}
}
__meta.FOREACH();
__meta.USE_LIST("t_chain");
}
__meta.END();
return(false);
}
internal static unsafe bool TryParse_t_data_type_display(string s, out t_data_type value)
{
t_data_type_remove_nullable value_type_value;
JArray jarray;
IF("$t_data_type->is_bool()");
{
IF("$t_data_type->is_nullable()");
{
if (string.IsNullOrEmpty(s) || string.Compare(s, "null", ignoreCase: true) == 0)
{
value = default(t_data_type);
return(true);
}
}
END();
double double_val;
if (t_data_type_remove_nullable.TryParse(s, out value_type_value))
{
value = value_type_value;
return(true);
}
else if (double.TryParse(s, out double_val))
{
LITERAL_OUTPUT("value = (double_val != 0);");
MUTE();
value = value_type_value;
MUTE_END();
return(true);
}
else
{
value = default(t_data_type);
return(false);
}
}
ELIF("$t_data_type->is_datetime()");
{
IF("$t_data_type->is_nullable()");
{
if (string.IsNullOrEmpty(s) || string.Compare(s, "null", ignoreCase: true) == 0)
{
value = default(t_data_type);
return(true);
}
}
END();
if (t_data_type_remove_nullable.TryParse(s, null, System.Globalization.DateTimeStyles.RoundtripKind, out value_type_value))
{
value = value_type_value;
return(true);
}
//special case for non-standard date time strings
if (s.EndsWith(" UTC", StringComparison.Ordinal) && t_data_type_remove_nullable.TryParse(s.Substring(0, s.Length - 4) + 'Z', null, System.Globalization.DateTimeStyles.RoundtripKind, out value_type_value))
{
//replace " UTC" with "Z"
value = value_type_value;
return(true);
}
value = default(t_data_type);
return(false);
}
ELIF("$t_data_type->is_nullable() /* and has built-in TryParse */");
if (string.IsNullOrEmpty(s) || string.Compare(s, "null", ignoreCase: true) == 0)
{
value = default(t_data_type);
return(true);
}
else if (t_data_type_remove_nullable.TryParse(s, out value_type_value))
{
value = value_type_value;
return(true);
}
else
{
value = default(t_data_type);
return(false);
}
ELIF("$t_data_type->is_array()");
try
{
MUTE();
//Just to make csc happy with the meta template.
value = default(t_data_type);
int t_array_iterator_length = 1;
string element = "";
MUTE_END();
jarray = JArray.Parse(s);
//There are some situations that our template system doesn't work...
//So we use LITERAL_OUTPUT to output something hard to express
LITERAL_OUTPUT("value = new "); META_OUTPUT("data_type_get_array_type_with_size_string($t_data_type)"); LITERAL_OUTPUT(";");
META_OUTPUT("$t_data_type_array_element_type"); LITERAL_OUTPUT(" element;");
int t_array_iterator_prefix_offset = 0;
FOREACH();
for (int t_array_iterator_string = 0; t_array_iterator_string < t_array_iterator_length; ++t_array_iterator_string)
/*END*/
{
IF("data_type_need_external_parser($t_data_type_array_element_type)");
{
if (!ExternalParser.TryParse_t_data_type_array_element_type((string)jarray[t_array_iterator_prefix_offset++], out element))
{
continue;
}
value[/*FOREACH(",")*/ t_array_iterator_string /*END*/] = element;
}
ELIF("$t_data_type_array_element_type->is_string()");
{
value[/*FOREACH(",")*/ t_array_iterator_string /*END*/] = (string)jarray[t_array_iterator_prefix_offset++];
}
ELSE();
{
if (!t_data_type_array_element_type.TryParse((string)jarray[t_array_iterator_prefix_offset++], out element))
{
continue;
}
value[/*FOREACH(",")*/ t_array_iterator_string /*END*/] = element;
}
END();
}
return(true);
}
catch
{
value = default(t_data_type);
return(false);
}
ELIF("$t_data_type->is_list()");
try
{
value = new t_data_type();
jarray = JArray.Parse(s);
foreach (var jarray_element in jarray)
{
t_data_type_list_element_type element;
IF("data_type_need_external_parser($t_data_type->listElementType)");
if (!ExternalParser.TryParse_t_data_type_list_element_type_display((string)jarray_element, out element))
{
continue;
//TODO what to do if we fail on an item?
//Same situation applies for arrays also.
//throw new Exception("Cannot parse \""+capture.Value+"\" into [META_OUTPUT($t_data_type->listElementType)].");
}
value.Add(element);
ELIF("$t_data_type->listElementType->is_string()");//Assign unescaped json string.
value.Add((string)jarray_element);
ELSE();
if (!t_data_type_list_element_type.TryParse((string)jarray_element, out element))
{
continue;
//throw new Exception("Cannot parse \""+capture.Value+"\" into [META_OUTPUT($t_data_type->listElementType)].");
}
value.Add(element);
END();
}
return(true);
}
catch
{
value = default(t_data_type);
return(false);
}
END();
}
internal static bool TryParse_t_field_type_list_element_type_display(t_data_type value, out t_field_type_list_element_type parseResult)
{
throw new NotImplementedException();
}
/// <summary>
/// Inserts an element into a sorted list.
/// </summary>
/// <param name="element">The object to insert.</param>
/// <param name="comparison"></param>
public unsafe void Insert(t_data_type element, Comparison <t_accessor_type> comparison)
{
byte *targetPtr = null;
{
MODULE_CALL("PushPointerFromVariable", "$t_data_type", "\"element\"", "\"push\"");
}
int size = (int)targetPtr;
targetPtr = m_ptr;
byte *endPtr = m_ptr + length;
while (targetPtr < endPtr)
{
IF("!%element_need_accessor");
{
if (comparison(*(t_accessor_type *)targetPtr, element) <= 0)
{
targetPtr += t_int;
}
else
{
break;
}
}
ELIF("%element_fixed");
{
elementAccessor.m_ptr = targetPtr;
if (comparison(elementAccessor, element) <= 0)
{
targetPtr += t_int;
}
else
{
break;
}
}
ELIF("data_type_is_length_prefixed(node->listElementType)");
ELIF("node->listElementType->is_struct()");
{
elementAccessor.m_ptr = targetPtr + 4;
if (comparison(elementAccessor, element) <= 0)
{
MODULE_CALL("PushPointerThroughFieldType", "$t_data_type");
}
else
{
break;
}
}
ELSE();
{
elementAccessor.m_ptr = targetPtr;
if (comparison(elementAccessor, element) <= 0)
{
MODULE_CALL("PushPointerThroughFieldType", "$t_data_type");
}
else
{
break;
}
}
END();
}
int offset = (int)(targetPtr - m_ptr);
// InsertAndRemoveAtCodeForContainer TODO IAccessor reuse
this.m_ptr = this.ResizeFunction(this.m_ptr - sizeof(int), offset + sizeof(int), size);
*(int *)this.m_ptr += size;
this.m_ptr += sizeof(int);
targetPtr = this.m_ptr + offset;
MODULE_CALL("PushPointerFromVariable", "$t_data_type", "\"element\"", "\"assign\"");
}
/// <summary>
/// Serializes a t_data_type object to Json string.
/// </summary>
/// <param name="value">The target object to be serialized.</param>
/// <returns>The serialized Json string.</returns>
public static string ToString(t_data_type value)
{
s_ensure_string_builder();
ToString_impl(value, s_stringBuilder, in_json: false);
return(s_stringBuilder.ToString());
}
private static void ToString_impl(t_data_type value, StringBuilder str_builder, bool in_json)
{
//For top-level element, just return the literal representation.
//For non-top-level element, it would be an element in a json structure. (object, or array)
//Thus we have to escape strings, surround fields with quotes (") if necessary.
IF("$t_data_type->is_string()");
if (in_json)
{
str_builder.Append(JsonStringProcessor.escape(value));
}
else
{
str_builder.Append(value);
}
ELIF("$t_data_type->is_struct()");
{
IF("$t_data_type->is_optional()");
if (value == null)
{
return;
}
END();
str_builder.Append('{');
bool first_field = true;
FOREACH();
{
IF("$t_field_type->is_nullable() || !$t_field_type->is_value_type()");
IF("$t_data_type->is_optional()");
if (value.Value.t_field_name != null)
{
ELSE();
}
if (value.t_field_name != null)
/*END*/
{
END();
if (first_field)
{
first_field = false;
}
else
{
str_builder.Append(',');
}
str_builder.Append("\"t_field_name\":");
IF("$t_data_type->is_optional()");
ToString_impl(value.Value.t_field_name, str_builder, in_json: true);
ELSE();
ToString_impl(value.t_field_name, str_builder, in_json: true);
END();
IF("$t_field_type->is_nullable() || !$t_field_type->is_value_type()");
}
END();
}
END();
str_builder.Append('}');
}
ELIF("$t_data_type->is_value_type()");
{
IF("$t_data_type->is_enum() || $t_data_type->is_datetime() || $t_data_type->is_guid()");
if (in_json)
{
str_builder.Append('"');
}
END();
IF("$t_data_type->is_bool()");
{
str_builder.Append(value.ToString().ToLowerInvariant());
}
ELIF("$t_data_type->is_datetime()");
{
IF("$t_data_type->is_nullable()");
{
str_builder.Append(value.Value.ToString("o", CultureInfo.InvariantCulture));
}
ELSE();
{
str_builder.Append(value.ToString("o", CultureInfo.InvariantCulture));
}
END();
}
ELSE();
{
str_builder.Append(value);
}
END();
IF("$t_data_type->is_enum() || $t_data_type->is_datetime() || $t_data_type->is_guid()");
if (in_json)
{
str_builder.Append('"');
}
END();
}
ELIF("$t_data_type->is_array() || $t_data_type->is_list()");
{
str_builder.Append('[');
bool first = true;
foreach (var element in value)
{
if (first)
{
first = false;
}
else
{
str_builder.Append(',');
}
ToString_impl(element, str_builder, in_json: true);
}
str_builder.Append(']');
}
ELSE();
throw new Exception("Internal error T5007");
END();
}
internal static t_data_type ConvertFrom_t_data_type_display(t_data_type value)
{
throw new NotImplementedException();
}
public static bool ElementContainsSubstring(this t_data_type list, params string[] substrings)
{
return(ElementContainsSubstring(list, substrings as IEnumerable <string>));
}
