private static void WriteArray_(
            ICurlyBracketStringBuilder cbsb,
            ITypeSymbol sourceSymbol,
            ISchemaMember member)
        {
            var arrayType = member.MemberType as ISequenceMemberType;

            if (arrayType.LengthSourceType != SequenceLengthSourceType.CONST)
            {
                var isImmediate =
                    arrayType.LengthSourceType ==
                    SequenceLengthSourceType.IMMEDIATE_VALUE;

                if (isImmediate)
                {
                    var writeType = SchemaGeneratorUtil.GetIntLabel(
                        arrayType.ImmediateLengthType);

                    var castType = SchemaGeneratorUtil.GetTypeName(
                        SchemaPrimitiveTypesUtil.ConvertIntToNumber(
                            arrayType.ImmediateLengthType));

                    var arrayLengthName = arrayType.SequenceType == SequenceType.ARRAY
                                    ? "Length"
                                    : "Count";
                    var arrayLengthAccessor = $"this.{member.Name}.{arrayLengthName}";

                    cbsb.WriteLine(
                        $"ew.Write{writeType}(({castType}) {arrayLengthAccessor});");
                }
            }

            SchemaWriterGenerator.WriteIntoArray_(cbsb, sourceSymbol, member);
        }
        private static void ReadPrimitive_(
            ICurlyBracketStringBuilder cbsb,
            ITypeSymbol sourceSymbol,
            ISchemaMember member)
        {
            var primitiveType = member.MemberType as IPrimitiveMemberType;

            if (primitiveType.PrimitiveType == SchemaPrimitiveType.BOOLEAN)
            {
                SchemaReaderGenerator.ReadBoolean_(cbsb, member);
                return;
            }

            var readType = SchemaGeneratorUtil.GetPrimitiveLabel(
                primitiveType.UseAltFormat
              ? SchemaPrimitiveTypesUtil.ConvertNumberToPrimitive(
                    primitiveType.AltFormat)
              : primitiveType.PrimitiveType);

            var needToCast = primitiveType.UseAltFormat &&
                             primitiveType.PrimitiveType !=
                             SchemaPrimitiveTypesUtil.GetUnderlyingPrimitiveType(
                SchemaPrimitiveTypesUtil.ConvertNumberToPrimitive(
                    primitiveType.AltFormat));

            if (!primitiveType.IsReadonly)
            {
                var castText = "";
                if (needToCast)
                {
                    var castType =
                        primitiveType.PrimitiveType == SchemaPrimitiveType.ENUM
                  ? SymbolTypeUtil.GetQualifiedNameFromCurrentSymbol(
                            sourceSymbol,
                            primitiveType.TypeSymbol)
                  : primitiveType.TypeSymbol.Name;
                    castText = $"({castType}) ";
                }
                cbsb.WriteLine(
                    $"this.{member.Name} = {castText}er.Read{readType}();");
            }
            else
            {
                var castText = "";
                if (needToCast)
                {
                    var castType =
                        SchemaGeneratorUtil.GetTypeName(primitiveType.AltFormat);
                    castText = $"({castType}) ";
                }
                cbsb.WriteLine($"er.Assert{readType}({castText}this.{member.Name});");
            }
        }
        private static void WriteBoolean_(
            ICurlyBracketStringBuilder cbsb,
            ISchemaMember member)
        {
            var primitiveType = member.MemberType as IPrimitiveMemberType;

            var writeType = SchemaGeneratorUtil.GetPrimitiveLabel(
                SchemaPrimitiveTypesUtil.ConvertNumberToPrimitive(
                    primitiveType.AltFormat));
            var castType = SchemaGeneratorUtil.GetTypeName(
                primitiveType.AltFormat);

            cbsb.WriteLine(
                $"ew.Write{writeType}(({castType}) (this.{member.Name} ? 1 : 0));");
        }
        private static void WritePrimitive_(
            ICurlyBracketStringBuilder cbsb,
            ISchemaMember member)
        {
            var primitiveType = member.MemberType as IPrimitiveMemberType;

            if (primitiveType.PrimitiveType == SchemaPrimitiveType.BOOLEAN)
            {
                SchemaWriterGenerator.WriteBoolean_(cbsb, member);
                return;
            }

            var readType = SchemaGeneratorUtil.GetPrimitiveLabel(
                primitiveType.UseAltFormat
              ? SchemaPrimitiveTypesUtil.ConvertNumberToPrimitive(
                    primitiveType.AltFormat)
              : primitiveType.PrimitiveType);

            var needToCast = primitiveType.UseAltFormat &&
                             primitiveType.PrimitiveType !=
                             SchemaPrimitiveTypesUtil.GetUnderlyingPrimitiveType(
                SchemaPrimitiveTypesUtil.ConvertNumberToPrimitive(
                    primitiveType.AltFormat));

            var castText = "";

            if (needToCast)
            {
                var castType =
                    SchemaGeneratorUtil.GetTypeName(primitiveType.AltFormat);
                castText = $"({castType}) ";
            }

            cbsb.WriteLine(
                $"ew.Write{readType}({castText}this.{member.Name});");
        }
        private static void WriteMember_(
            ICurlyBracketStringBuilder cbsb,
            ITypeSymbol sourceSymbol,
            ISchemaMember member)
        {
            if (member.IsPosition)
            {
                return;
            }

            if (member.Offset != null)
            {
                cbsb.WriteLine("throw new NotImplementedException();");
                return;
            }

            SchemaWriterGenerator.Align_(cbsb, member);

            var ifBoolean = member.IfBoolean;

            if (ifBoolean != null)
            {
                if (ifBoolean.SourceType == IfBooleanSourceType.IMMEDIATE_VALUE)
                {
                    var booleanNumberType =
                        SchemaPrimitiveTypesUtil.ConvertIntToNumber(
                            ifBoolean.ImmediateBooleanType);
                    var booleanPrimitiveType =
                        SchemaPrimitiveTypesUtil.ConvertNumberToPrimitive(
                            booleanNumberType);
                    var booleanNumberLabel =
                        SchemaGeneratorUtil.GetTypeName(booleanNumberType);
                    var booleanPrimitiveLabel =
                        SchemaGeneratorUtil.GetPrimitiveLabel(booleanPrimitiveType);
                    cbsb.WriteLine(
                        $"ew.Write{booleanPrimitiveLabel}(({booleanNumberLabel}) (this.{member.Name} != null ? 1 : 0));")
                    .EnterBlock($"if (this.{member.Name} != null)");
                }
                else
                {
                    cbsb.EnterBlock($"if (this.{ifBoolean.BooleanMember.Name})");
                }
            }

            var memberType = member.MemberType;

            if (memberType is IGenericMemberType genericMemberType)
            {
                memberType = genericMemberType.ConstraintType;
            }

            switch (memberType)
            {
            case IPrimitiveMemberType: {
                SchemaWriterGenerator.WritePrimitive_(cbsb, member);
                break;
            }

            case IStringType: {
                SchemaWriterGenerator.WriteString_(cbsb, member);
                break;
            }

            case IStructureMemberType structureMemberType: {
                SchemaWriterGenerator.WriteStructure_(cbsb, member);
                break;
            }

            case ISequenceMemberType: {
                SchemaWriterGenerator.WriteArray_(cbsb, sourceSymbol, member);
                break;
            }

            default:
                // Anything that makes it down here probably isn't meant to be read.
                throw new NotImplementedException();
            }

            if (ifBoolean != null)
            {
                cbsb.ExitBlock();
            }
        }
        private static void ReadIntoArray_(
            ICurlyBracketStringBuilder cbsb,
            ITypeSymbol sourceSymbol,
            ISchemaMember member)
        {
            var arrayType = member.MemberType as ISequenceMemberType;

            var elementType = arrayType.ElementType;

            if (elementType is IGenericMemberType genericElementType)
            {
                elementType = genericElementType.ConstraintType;
            }

            if (elementType is IPrimitiveMemberType primitiveElementType)
            {
                // Primitives that don't need to be cast are the easiest to read.
                if (!primitiveElementType.UseAltFormat)
                {
                    var label =
                        SchemaGeneratorUtil.GetPrimitiveLabel(
                            primitiveElementType.PrimitiveType);
                    if (!primitiveElementType.IsReadonly)
                    {
                        cbsb.WriteLine($"er.Read{label}s(this.{member.Name});");
                    }
                    else
                    {
                        cbsb.WriteLine($"er.Assert{label}s(this.{member.Name});");
                    }
                    return;
                }

                // Primitives that *do* need to be cast have to be read individually.
                var readType = SchemaGeneratorUtil.GetPrimitiveLabel(
                    SchemaPrimitiveTypesUtil.ConvertNumberToPrimitive(
                        primitiveElementType.AltFormat));
                if (!primitiveElementType.IsReadonly)
                {
                    var arrayLengthName = arrayType.SequenceType == SequenceType.ARRAY
                                    ? "Length"
                                    : "Count";
                    var castType =
                        primitiveElementType.PrimitiveType == SchemaPrimitiveType.ENUM
                  ? SymbolTypeUtil.GetQualifiedNameFromCurrentSymbol(
                            sourceSymbol,
                            primitiveElementType.TypeSymbol)
                  : primitiveElementType.TypeSymbol.Name;
                    cbsb.EnterBlock(
                        $"for (var i = 0; i < this.{member.Name}.{arrayLengthName}; ++i)")
                    .WriteLine(
                        $"this.{member.Name}[i] = ({castType}) er.Read{readType}();")
                    .ExitBlock();
                }
                else
                {
                    var castType =
                        SchemaGeneratorUtil.GetTypeName(primitiveElementType.AltFormat);
                    cbsb.EnterBlock($"foreach (var e in this.{member.Name})")
                    .WriteLine($"er.Assert{readType}(({castType}) e);")
                    .ExitBlock();
                }
                return;
            }

            if (elementType is IStructureMemberType structureElementType)
            {
                //if (structureElementType.IsReferenceType) {
                cbsb.EnterBlock($"foreach (var e in this.{member.Name})");

                if (structureElementType.IsChild)
                {
                    cbsb.WriteLine("e.Parent = this;");
                }

                cbsb.WriteLine("e.Read(er);");
                cbsb.ExitBlock();
                // TODO: Do value types need to be read like below?

                /*}
                 * // Value types (mainly structs) have to be pulled out, read, then put
                 * // back in.
                 * else {
                 * var arrayLengthName = arrayType.SequenceType == SequenceType.ARRAY
                 *                          ? "Length"
                 *                          : "Count";
                 * cbsb.EnterBlock(
                 *        $"for (var i = 0; i < this.{member.Name}.{arrayLengthName}; ++i)")
                 *    .WriteLine($"var e = this.{member.Name}[i];")
                 *    .WriteLine("e.Read(er);")
                 *    .WriteLine($"this.{member.Name}[i] = e;")
                 *    .ExitBlock();
                 * }*/
                return;
            }

// Anything that makes it down here probably isn't meant to be read.
            throw new NotImplementedException();
        }