public static string ToCsvString(this IArrayAccessor wrappedArray, bool useHeader = false)
{
try
{
using (var ms = new MemoryStream())
using (var writer = new StreamWriter(ms, Encoding.UTF8))
using (var reader = new StreamReader(ms))
using (var csv = new CsvWriter(writer, CultureInfo.InvariantCulture))
{
RegisterClassMap(wrappedArray.InnerType, csv);
csv.Configuration.HasHeaderRecord = useHeader;
csv.WriteRecords(wrappedArray);
writer.Flush();
ms.Seek(0, SeekOrigin.Begin);
var s = reader.ReadToEnd();
return(s);
}
}
catch (Exception e)
{
MainController.LogString("Creating Csv file failed, please double-check your input.", Logtype.Error);
return(null);
}
}
public Block(StorageOptions storageOptions, ReadOptions readOptions, BlockHandle handle, FileData fileData)
{
try
{
_handle = handle;
_storageOptions = storageOptions;
_fileData = fileData;
if (handle.Position > fileData.Size || (handle.Position + handle.Count + BlockTrailerSize) > fileData.Size)
throw new CorruptedDataException("The specified accessor is beyond the bounds of the provided mappedFile");
_accessor = _fileData.File.CreateAccessor(handle.Position, handle.Count + BlockTrailerSize);
if (readOptions.VerifyChecksums)
{
var crc = Crc.Unmask(_accessor.ReadInt32(handle.Count + 1));
var actualCrc = CalculateActualCrc(handle.Count + 1); // data + tag
if (crc != actualCrc)
throw new CorruptedDataException("block checksum mismatch");
}
RestartsCount = _accessor.ReadInt32(handle.Count - sizeof(int));
RestartsOffset = handle.Count - (RestartsCount * sizeof(int)) - sizeof(int);
if (RestartsOffset > handle.Count)
throw new CorruptedDataException("restart offset wrapped around");
}
catch (Exception)
{
Dispose();
throw;
}
}
public CloneArrayReplicationStrategy(Type elementType)
{
this.elementType = elementType;
IArrayAccessor arrayAccessor = ArrayAccessorBuilder.BuildForArrayOf(elementType);
getElement = arrayAccessor.GetElement;
setElement = arrayAccessor.SetElement;
}
public BloomFilter(byte baseLg, int offset, IArrayAccessor accessor, BloomFilterPolicy bloomFilterPolicy)
{
_baseLg = baseLg;
_accessor = accessor;
_bloomFilterPolicy = bloomFilterPolicy;
_offset = offset;
_num = (accessor.Capacity - 5 - offset)/sizeof (int);
}
protected override void SetUp()
{
base.SetUp();
var random = new Random();
array = Enumerable.Range(0, 100)
.Select(_ => random.NextDouble())
.ToArray();
number = random.NextDouble();
arrayAccessor = ArrayAccessorBuilder.BuildForArrayOf(typeof(double));
}
protected override void SetUp()
{
base.SetUp();
var random = new Random();
array = Enumerable.Range(0, 100)
.Select(_ => random.NextDouble())
.ToArray();
number = random.NextDouble();
arrayAccessor = ArrayAccessorBuilder.BuildForArrayOf(typeof (double));
}
public IFilter CreateFilter(IArrayAccessor accessor)
{
if (accessor.Capacity < 5) // 1 byte for base, 4 for start of offset array
return null;
var baseLg = accessor[accessor.Capacity - 1];
var lastWord = accessor.ReadInt32(accessor.Capacity - 5);
if (lastWord > accessor.Capacity - 5)
return null;
return new BloomFilter(baseLg, lastWord, accessor, this);
}
public void DecodeFrom(IArrayAccessor accessor)
{
for (int i = 0; i < _tableMagicBytes.Length; i++)
{
var b = accessor[EncodedLength - _tableMagicBytes.Length + i];
if( b != _tableMagicBytes[i])
throw new InvalidOperationException("Not a sstable (bad magic number)");
}
MetaIndexHandle = new BlockHandle();
IndexHandle = new BlockHandle();
var size = MetaIndexHandle.DecodeFrom(accessor, 0);
IndexHandle.DecodeFrom(accessor, size);
}
/// <summary>
/// The instantiation step of the RedEngine-3 reflection.
/// </summary>
/// <param name="typename">Can be either a generic type such as CUint32 - then converted with GetWKitTypeFromREDType, or a complex type like a
/// pointer to a class, a handle to an import file, an array, a soft reference, a static reference, various buffers, an enum.</param>
/// <param name="varname">The variable name</param>
/// <param name="cr2w">The cr2w base file</param>
/// <param name="parentVariable">The class owning this attribute</param>
/// <param name="readUnknownAsBytes"></param>
/// <returns></returns>
public static CVariable Create(string typename, string varname, CR2WFile cr2w, CVariable parentVariable, bool readUnknownAsBytes = true)
{
typename = REDReflection.GetWKitBaseTypeFromREDBaseType(typename);
var fullname = typename;
// check for normal type
if (AssemblyDictionary.TypeExists(typename))
{
var type = AssemblyDictionary.GetTypeByName(typename);
if (type != null)
{
object instance = System.Activator.CreateInstance(type, cr2w, parentVariable, varname);
return(instance as CVariable);
}
}
// check for enum types
if (AssemblyDictionary.EnumExists(typename))
{
Enum e = (Enum)System.Activator.CreateInstance(AssemblyDictionary.GetEnumByName(typename));
var cenum = MakeGenericEnumType(typeof(CEnum <>), e);
return(cenum);
}
else if (CR2WManager.EnumExists(typename))
{
Enum e = (Enum)System.Activator.CreateInstance(CR2WManager.GetEnumByName(typename));
var cenum = MakeGenericEnumType(typeof(CEnum <>), e);
return(cenum);
}
// check for generic type
else if (typename.StartsWith('['))
{
string generictype = typename.Substring(3);
CVariable innerobject = Create(generictype, "", cr2w, null);
var arrayacc = MakeArray(typeof(CArrayFixedSize <>), innerobject.GetType());
//arrayacc.Flags = new List<int>() { int.Parse(matchArrayType.Groups[1].Value) };
arrayacc.Elementtype = generictype;
return(arrayacc as CVariable);
}
else if (typename.Contains(':'))
{
#region GENERIC TYPES
string[] splits = typename.Split(':');
string generictype = splits.First();
string innertype = string.Join(":", splits.Skip(1));
// e.g. handle:CEntityTemplate
switch (generictype)
{
case "CHandle":
case "handle":
{
CVariable innerobject = Create(innertype, "", cr2w, null);
return(MakeGenericType(typeof(CHandle <>), innerobject));
}
case "wCHandle":
case "whandle":
{
CVariable innerobject = Create(innertype, "", cr2w, null);
return(MakeGenericType(typeof(wCHandle <>), innerobject));
}
case "CrRef":
case "rRef":
{
CVariable innerobject = Create(innertype, "", cr2w, null);
return(MakeGenericType(typeof(rRef <>), innerobject));
}
case "CraRef":
case "raRef":
{
CVariable innerobject = Create(innertype, "", cr2w, null);
return(MakeGenericType(typeof(raRef <>), innerobject));
}
case "array":
{
// match pattern e.g.
// array: (array:)Float
// array of array: (array:)handle:meshMeshAppearance
CVariable innerobject = Create(innertype, "", cr2w, null);
IArrayAccessor arrayacc = MakeArray(typeof(CArray <>), innerobject.GetType());
arrayacc.Elementtype = innertype;
return(arrayacc as CVariable);
}
case "static":
{
typename = generictype;
// match pattern e.g.
// static: (4),(Uint32)
var regArrayType = new Regex(@"(\d+),(.+)");
var matchArrayType = regArrayType.Match(fullname);
if (matchArrayType.Success)
{
CVariable innerobject = Create(matchArrayType.Groups[2].Value, "", cr2w, null);
var arrayacc = MakeArray(typeof(CStatic <>), innerobject.GetType());
//arrayacc.Flags = new List<int>() { int.Parse(matchArrayType.Groups[1].Value) };
arrayacc.Elementtype = matchArrayType.Groups[2].Value;
return(arrayacc as CVariable);
}
else
{
throw new InvalidParsingException($"Invalid static type format: typename: {typename}.");
}
}
case "CEnum":
{
Enum innerobject = CreateEnum(innertype);
return(MakeGenericEnumType(typeof(CEnum <>), innerobject));
}
default:
{
throw new MissingTypeException(generictype);
}
}
#endregion
}
else
{
// check if custom type
if (CR2WManager.TypeExists(typename))
{
var type = CR2WManager.GetTypeByName(typename);
object instance = System.Activator.CreateInstance(type, cr2w, parentVariable, varname);
return(instance as CVariable);
}
// this should never happen
if (!cr2w.UnknownTypes.Contains(fullname))
{
cr2w.UnknownTypes.Add(fullname);
}
if (readUnknownAsBytes)
{
return(new CBytes(cr2w, parentVariable, $"UNKNOWN:{typename}:{varname}"));
}
else
{
return(null);
}
}
#region LOCAL FUNCTIONS
IArrayAccessor MakeArray(Type arraytype, Type generictype)
{
Type elementType;
if (arraytype == typeof(CStatic <>))
{
elementType = typeof(CStatic <>).MakeGenericType(generictype);
}
else if (arraytype == typeof(CArrayFixedSize <>))
{
elementType = typeof(CArrayFixedSize <>).MakeGenericType(generictype);
}
else if (arraytype == typeof(CArray <>))
{
elementType = typeof(CArray <>).MakeGenericType(generictype);
}
else
{
throw new NotImplementedException();
}
var array = System.Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
return(array as IArrayAccessor);
}
CVariable MakeGenericType(Type gentype, CVariable innerobject)
{
if (innerobject != null)
{
Type elementType = gentype.MakeGenericType(innerobject.GetType());
CVariable handle = System.Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
return(handle);
}
else
{
throw new Exception();
}
}
CVariable MakeGenericEnumType(Type gentype, Enum innerobject)
{
if (innerobject != null)
{
Type elementType = gentype.MakeGenericType(innerobject.GetType());
CVariable handle = System.Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
return(handle);
}
else
{
throw new Exception();
}
}
#endregion
}
/// <summary>
/// The instantiation step of the RedEngine-3 reflection.
/// </summary>
/// <param name="typename">Can be either a generic type such as CUint32 - then converted with GetWKitTypeFromREDType, or a complex type like a
/// pointer to a class, a handle to an import file, an array, a soft reference, a static reference, various buffers, an enum.</param>
/// <param name="varname">The variable name</param>
/// <param name="cr2w">The cr2w base file</param>
/// <param name="parentVariable">The class owning this attribute</param>
/// <param name="readUnknownAsBytes"></param>
/// <returns></returns>
public static CVariable Create(string typename, string varname, CR2WFile cr2w, CVariable parentVariable, bool readUnknownAsBytes = true)
{
typename = REDReflection.GetWKitBaseTypeFromREDBaseType(typename);
var fullname = typename;
// check for normal type
if (AssemblyDictionary.TypeExists(typename))
{
var type = AssemblyDictionary.GetTypeByName(typename);
if (type != null)
{
object instance = Activator.CreateInstance(type, cr2w, parentVariable, varname);
return(instance as CVariable);
}
}
// check for enum types
if (AssemblyDictionary.EnumExists(typename))
{
Enum e = (Enum)Activator.CreateInstance(AssemblyDictionary.GetEnumByName(typename));
var cenum = MakeGenericEnumType(typeof(CEnum <>), e);
return(cenum);
}
else if (CR2WManager.EnumExists(typename))
{
Enum e = (Enum)Activator.CreateInstance(CR2WManager.GetEnumByName(typename));
var cenum = MakeGenericEnumType(typeof(CEnum <>), e);
return(cenum);
}
// check for generic type
else if (typename.Contains(':'))
{
#region GENERIC TYPES
string[] splits = typename.Split(':');
string generictype = splits.First();
string innertype = string.Join(":", splits.Skip(1));
// e.g. handle:CEntityTemplate
switch (generictype)
{
case "CHandle":
case "handle":
{
CVariable innerobject = Create(innertype, "", cr2w, null);
return(MakeGenericType(typeof(CHandle <>), innerobject));
}
case "CPtr":
case "ptr":
{
CVariable innerobject = Create(innertype, "", cr2w, null);
return(MakeGenericType(typeof(CPtr <>), innerobject));
}
case "CSoft":
case "soft":
{
CVariable innerobject = Create(innertype, "", cr2w, null);
return(MakeGenericType(typeof(CSoft <>), innerobject));
}
case "array":
{
// match pattern e.g.
// array: Array: (2),(0),(handle:CBitmapTexture)
// array: Array: (2),(0),(Int32)
// array of array: Array: (2),(0),(Array:133,0,EngineQsTransform)
string[] arraysplits = innertype.Split(',');
string flag1 = arraysplits[0];
string flag2 = arraysplits[1];
string body = string.Join(",", arraysplits.Skip(2));
if (arraysplits.Length >= 3)
{
//byte arrays, these can be huge, using ordinary arrays is just too slow.
if (body == "Uint8" || body == "Int8")
{
var bytearray = new CByteArray(cr2w, parentVariable, varname);
// save the actual redengine type for serialization: e.g. array:2,0,Uint8
bytearray.InternalType = typename;
return(bytearray);
}
// all other arrays
CVariable innerobject = Create(body, "", cr2w, null);
IArrayAccessor arrayacc = MakeArray(typeof(CArray <>), innerobject.GetType());
arrayacc.Flags = new List <int>()
{
int.Parse(flag1), int.Parse(flag2)
};
if (innerobject is IArrayAccessor accessor && accessor.Flags != null)
{
arrayacc.Flags.AddRange(accessor.Flags);
}
arrayacc.Elementtype = body;
return(arrayacc as CVariable);
}
else
{
CVariable innerobject = Create(innertype, "", cr2w, null);
IArrayAccessor arrayacc = MakeArray(typeof(CArray <>), innerobject.GetType());
arrayacc.Elementtype = body;
return(arrayacc as CVariable);
}
}
case "static":
{
typename = generictype;
// match pattern e.g.
// static: (4),(Uint32)
var regArrayType = new Regex(@"(\d+),(.+)");
var matchArrayType = regArrayType.Match(fullname);
if (matchArrayType.Success)
{
CVariable innerobject = Create(matchArrayType.Groups[2].Value, "", cr2w, null);
var arrayacc = MakeArray(typeof(CStatic <>), innerobject.GetType());
arrayacc.Flags = new List <int>()
{
int.Parse(matchArrayType.Groups[1].Value)
};
arrayacc.Elementtype = matchArrayType.Groups[2].Value;
return(arrayacc as CVariable);
}
else
{
throw new InvalidParsingException($"Invalid static type format: typename: {typename}.");
}
}
case "CBufferUInt16":
{
CVariable innerobject = Create(innertype, "", cr2w, null);
return(MakeGenericType(typeof(CBufferUInt16 <>), innerobject));
}
case "CBufferUInt32":
{
CVariable innerobject = Create(innertype, "", cr2w, null);
return(MakeGenericType(typeof(CBufferUInt32 <>), innerobject));
}
case "CBufferVLQInt32":
{
CVariable innerobject = Create(innertype, "", cr2w, null);
return(MakeGenericType(typeof(CBufferVLQInt32 <>), innerobject));
}
case "CCompressedBuffer":
{
CVariable innerobject = Create(innertype, "", cr2w, null);
return(MakeGenericType(typeof(CCompressedBuffer <>), innerobject));
}
case "CPaddedBuffer":
{
CVariable innerobject = Create(innertype, "", cr2w, null);
return(MakeGenericType(typeof(CPaddedBuffer <>), innerobject));
}
case "CEnum":
{
Enum innerobject = CreateEnum(innertype);
return(MakeGenericEnumType(typeof(CEnum <>), innerobject));
}
default:
{
throw new NotImplementedException();
}
}
#endregion
}
else
{
#region FIXED SIZE ARRAYS
// match pattern e.g.
// [(1)](Bezier2dHandle)
var regFixedSizeArray = new Regex(@"^\[(\d+)\](.+)$");
var matchFixedSizeArray = regFixedSizeArray.Match(typename);
if (matchFixedSizeArray.Success)
{
CVariable innerobject = Create(matchFixedSizeArray.Groups[2].Value, "", cr2w, null);
var arrayacc = MakeArray(typeof(CArrayFixedSize <>), innerobject.GetType());
arrayacc.Flags = new List <int>()
{
int.Parse(matchFixedSizeArray.Groups[1].Value)
};
arrayacc.Elementtype = matchFixedSizeArray.Groups[2].Value;
return(arrayacc as CVariable);
}
#endregion
if (fullname.Contains("@SItem"))
{
cr2w.UnknownTypes.Add($"Congratulations! You have found one of the hidden e3 files! These files are special." +
$" If you edited this file and are experiencing errors, please contact a member of the Wkit Team. ErrorCode: {fullname}");
return(new SItem(cr2w, parentVariable, varname));
}
else if (fullname.Contains("#CEnvironmentDefinition"))
{
cr2w.UnknownTypes.Add($"Congratulations! You have found one of the hidden e3 files! These files are special." +
$" If you edited this file and are experiencing errors, please contact a member of the Wkit Team. ErrorCode: {fullname}");
return(new CHandle <CEnvironmentDefinition>(cr2w, parentVariable, varname));
}
else
{
// check if custom type
if (CR2WManager.TypeExists(typename))
{
var type = CR2WManager.GetTypeByName(typename);
object instance = Activator.CreateInstance(type, cr2w, parentVariable, varname);
return(instance as CVariable);
}
// this should never happen
if (!cr2w.UnknownTypes.Contains(fullname))
{
cr2w.UnknownTypes.Add(fullname);
}
if (readUnknownAsBytes)
{
return(new CBytes(cr2w, parentVariable, $"UNKNOWN:{typename}:{varname}"));
}
else
{
return(null);
}
}
}
#region LOCAL FUNCTIONS
IArrayAccessor MakeArray(Type arraytype, Type generictype)
{
Type elementType;
if (arraytype == typeof(CStatic <>))
{
elementType = typeof(CStatic <>).MakeGenericType(generictype);
}
else if (arraytype == typeof(CArrayFixedSize <>))
{
elementType = typeof(CArrayFixedSize <>).MakeGenericType(generictype);
}
else if (arraytype == typeof(CArray <>))
{
elementType = typeof(CArray <>).MakeGenericType(generictype);
}
else
{
throw new NotImplementedException();
}
var array = Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
return(array as IArrayAccessor);
}
CVariable MakeGenericType(Type gentype, CVariable innerobject)
{
if (innerobject != null)
{
Type elementType = gentype.MakeGenericType(innerobject.GetType());
CVariable handle = Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
return(handle);
}
else
{
throw new Exception();
}
}
CVariable MakeGenericEnumType(Type gentype, Enum innerobject)
{
if (innerobject != null)
{
Type elementType = gentype.MakeGenericType(innerobject.GetType());
CVariable handle = Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
return(handle);
}
else
{
throw new Exception();
}
}
#endregion
}
/// <summary>
/// The instantiation step of the RedEngine-3 reflection.
/// </summary>
/// <param name="typename">Can be either a generic type such as CUint32 - then converted with GetWKitTypeFromREDType, or a complex type like a
/// pointer to a class, a handle to an import file, an array, a soft reference, a static reference, various buffers, an enum.</param>
/// <param name="varname">The variable name</param>
/// <param name="cr2w">The cr2w base file</param>
/// <param name="parentVariable">The class owning this attribute</param>
/// <param name="readUnknownAsBytes"></param>
/// <returns></returns>
public static CVariable Create(string typename, string varname, CR2WFile cr2w, CVariable parentVariable, bool readUnknownAsBytes = true)
{
typename = REDReflection.GetWKitBaseTypeFromREDBaseType(typename);
// first try to create instance of type
#region W3 TYPES
try
{
var type = Type.GetType($"WolvenKit.CR2W.Types.{typename}", false, false);
// if succesful return as CVariable
if (type != null)
{
//var instance = type.GetMethod("Create").Invoke(type, new object[]{ cr2w, parentVariable, varname });
object instance = Activator.CreateInstance(type, cr2w, parentVariable, varname);
return(instance as CVariable);
}
}
catch (System.IO.FileLoadException)
{
}
#endregion
var fullname = typename;
// check for enum
if (typeof(Enums).GetNestedTypes().Select(_ => _.Name).Contains(typename))
{
Enum e = (Enum)Activator.CreateInstance(typeof(Enums).GetNestedTypes().FirstOrDefault(_ => _.Name == typename));
//if (e.GetType().IsDefined(typeof(FlagsAttribute), false))
//{
// typename = REDReflection.GetWKitTypeFromREDType(typename);
// var etype = Type.GetType($"WolvenKit.CR2W.Types.{typename}");
// object einstance = Activator.CreateInstance(etype, cr2w, parentVariable, varname);
// return einstance as CVariable;
//}
var cenum = MakeGenericEnumType(typeof(CEnum <>), e);
return(cenum);
}
// finally, check for generic type
else if (typename.Contains(':'))
{
//try
//{
#region GENERIC TYPES
// match pattern e.g.
// (handle):(CGenericGrassMask) or
// (array):(2,0,handle:CBitmapTexture)
var reg = new Regex(@"^(\w+):(.+)$");
var match = reg.Match(typename);
if (match.Success)
{
switch (match.Groups[1].Value)
{
case "CHandle":
case "handle":
{
CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
return(MakeGenericType(typeof(CHandle <>), innerobject));
}
case "CPtr":
case "ptr":
{
CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
return(MakeGenericType(typeof(CPtr <>), innerobject));
}
case "CSoft":
case "soft":
{
CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
return(MakeGenericType(typeof(CSoft <>), innerobject));
}
case "array":
{
typename = match.Groups[1].Value;
// match pattern e.g.
// array: Array: (2),(0),(handle:CBitmapTexture)
// array: Array: (2),(0),(Int32)
// array of array: Array: (2),(0),(Array:133,0,EngineQsTransform)
var regArrayType = new Regex(@"(\d+),(\d+),(.+)");
var matchArrayType = regArrayType.Match(fullname);
if (matchArrayType.Success)
{
//byte arrays, these can be huge, using ordinary arrays is just too slow.
if (matchArrayType.Groups[3].Value == "Uint8" || matchArrayType.Groups[3].Value == "Int8")
{
var bytearray = new CByteArray(cr2w, parentVariable, varname);
bytearray.InternalType = fullname;
return(bytearray);
}
CVariable innerobject = Create(matchArrayType.Groups[3].Value, "", cr2w, null);
IArrayAccessor arrayacc = MakeArray(typeof(CArray <>), innerobject.GetType());
arrayacc.Flags = new List <int>()
{
int.Parse(matchArrayType.Groups[1].Value), int.Parse(matchArrayType.Groups[2].Value)
};
if (innerobject is IArrayAccessor accessor && accessor.Flags != null)
{
arrayacc.Flags.AddRange(accessor.Flags);
}
arrayacc.Elementtype = matchArrayType.Groups[3].Value;
return(arrayacc as CVariable);
}
// for CArrays of other types
else
{
//throw new InvalidParsingException($"Invalid array type format: typename: {typename}.");
CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
IArrayAccessor arrayacc = MakeArray(typeof(CArray <>), innerobject.GetType());
arrayacc.Elementtype = matchArrayType.Groups[3].Value;
return(arrayacc as CVariable);
}
}
case "static":
{
typename = match.Groups[1].Value;
// match pattern e.g.
// static: (4),(Uint32)
var regArrayType = new Regex(@"(\d+),(.+)");
var matchArrayType = regArrayType.Match(fullname);
if (matchArrayType.Success)
{
CVariable innerobject = Create(matchArrayType.Groups[2].Value, "", cr2w, null);
var arrayacc = MakeArray(typeof(CStatic <>), innerobject.GetType());
arrayacc.Flags = new List <int>()
{
int.Parse(matchArrayType.Groups[1].Value)
};
arrayacc.Elementtype = matchArrayType.Groups[2].Value;
return(arrayacc as CVariable);
}
else
{
throw new InvalidParsingException($"Invalid static type format: typename: {typename}.");
}
}
case "CBufferUInt16":
{
CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
return(MakeGenericType(typeof(CBufferUInt16 <>), innerobject));
}
case "CBufferUInt32":
{
CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
return(MakeGenericType(typeof(CBufferUInt32 <>), innerobject));
}
case "CBufferVLQInt32":
{
CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
return(MakeGenericType(typeof(CBufferVLQInt32 <>), innerobject));
}
case "CCompressedBuffer":
{
CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
return(MakeGenericType(typeof(CCompressedBuffer <>), innerobject));
}
case "CPaddedBuffer":
{
CVariable innerobject = Create(match.Groups[2].Value, "", cr2w, null);
return(MakeGenericType(typeof(CPaddedBuffer <>), innerobject));
}
case "CEnum":
{
Enum innerobject = CreateEnum(match.Groups[2].Value);
return(MakeGenericEnumType(typeof(CEnum <>), innerobject));
}
default:
{
typename = match.Groups[1].Value;
throw new NotImplementedException();
break;
}
}
}
else
{
throw new NotImplementedException();
}
#endregion
//}
//catch (Exception ex)
//{
// throw ex;
//}
}
else
{
#region FIXED SIZE ARRAYS
// match pattern e.g.
// [(1)](Bezier2dHandle)
var regFixedSizeArray = new Regex(@"^\[(\d+)\](.+)$");
var matchFixedSizeArray = regFixedSizeArray.Match(typename);
if (matchFixedSizeArray.Success)
{
CVariable innerobject = Create(matchFixedSizeArray.Groups[2].Value, "", cr2w, null);
var arrayacc = MakeArray(typeof(CArrayFixedSize <>), innerobject.GetType());
arrayacc.Flags = new List <int>()
{
int.Parse(matchFixedSizeArray.Groups[1].Value)
};
arrayacc.Elementtype = matchFixedSizeArray.Groups[2].Value;
return(arrayacc as CVariable);
}
#endregion
if (fullname.Contains("@SItem"))
{
cr2w.UnknownTypes.Add($"Congratulations! You have found one of the hidden e3 files! These files are special." +
$" If you edited this file and are experiencing errors, please contact a member of the Wkit Team. ErrorCode: {fullname}");
return(new SItem(cr2w, parentVariable, varname));
}
else if (fullname.Contains("#CEnvironmentDefinition"))
{
cr2w.UnknownTypes.Add($"Congratulations! You have found one of the hidden e3 files! These files are special." +
$" If you edited this file and are experiencing errors, please contact a member of the Wkit Team. ErrorCode: {fullname}");
return(new CHandle <CEnvironmentDefinition>(cr2w, parentVariable, varname));
}
else
{
if (!cr2w.UnknownTypes.Contains(fullname))
{
cr2w.UnknownTypes.Add(fullname);
}
// this should never happen
if (readUnknownAsBytes)
{
return(new CBytes(cr2w, parentVariable, "unknownBytes"));
}
else
{
return(null);
}
}
}
#region LOCAL FUNCTIONS
IArrayAccessor MakeArray(Type arraytype, Type generictype)
{
Type elementType = typeof(CArray <>);
if (arraytype == typeof(CStatic <>))
{
elementType = typeof(CStatic <>).MakeGenericType(generictype);
}
else if (arraytype == typeof(CArrayFixedSize <>))
{
elementType = typeof(CArrayFixedSize <>).MakeGenericType(generictype);
}
else if (arraytype == typeof(CArray <>))
{
elementType = typeof(CArray <>).MakeGenericType(generictype);
}
else
{
throw new NotImplementedException();
}
var array = Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
return(array as IArrayAccessor);
}
CVariable MakeGenericType(Type gentype, CVariable innerobject)
{
if (innerobject != null)
{
Type elementType = gentype.MakeGenericType(innerobject.GetType());
CVariable handle = Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
return(handle);
}
else
{
throw new Exception();
}
}
CVariable MakeGenericEnumType(Type gentype, Enum innerobject)
{
if (innerobject != null)
{
Type elementType = gentype.MakeGenericType(innerobject.GetType());
CVariable handle = Activator.CreateInstance(elementType, cr2w, parentVariable, varname) as CVariable;
return(handle);
}
else
{
throw new Exception();
}
}
#endregion
}
public int DecodeFrom(IArrayAccessor accessor, int pos)
{
Position = accessor.Read7BitEncodedLong(ref pos);
Count = accessor.Read7BitEncodedLong(ref pos);
return pos;
}
