private static void Render([NotNull] HerculesVector vector, [NotNull] StringBuilder builder, int depth)
        {
            if (vector.Count == 0)
            {
                builder
                .Indent(depth)
                .Append(OpeningSquareBracket)
                .Append(ClosingSquareBracket);

                return;
            }

            builder
            .Indent(depth)
            .AppendLine(OpeningSquareBracket);

            var counter = 0;

            foreach (var element in vector.Elements)
            {
                Render(element, builder, depth + 1);

                if (++counter < vector.Count)
                {
                    builder.Append(Comma);
                }

                builder.AppendLine();
            }

            builder
            .Indent(depth)
            .Append(ClosingSquareBracket);
        }
        public static string Render([NotNull] HerculesVector vector, int startingDepth = 0)
        {
            var builder = new StringBuilder();

            Render(vector, builder, startingDepth);

            return(builder.ToString());
        }
Exemple #3
0
        public void Should_have_target_type_name_in_InvalidCastException_message_thrown_by_As_method()
        {
            var value = new HerculesVector <int>(new[] { 1, 2, 3 });

            new Action(() => value.AsLongList.GetHashCode())
            .Should()
            .Throw <InvalidCastException>()
            .Where(x => x.Message.Contains(typeof(long).ToString()));
        }
        public static IHerculesTagsBuilder AddVector(this IHerculesTagsBuilder builder, string key, HerculesVector vector)
        {
            switch (vector.ElementType)
            {
            case HerculesValueType.String:
                builder.AddVector(key, vector.AsStringList);
                break;

            case HerculesValueType.Long:
                builder.AddVector(key, vector.AsLongList);
                break;

            case HerculesValueType.Guid:
                builder.AddVector(key, vector.AsGuidList);
                break;

            case HerculesValueType.Container:
                builder.AddVectorOfContainers(key, vector.AsContainerList, (tagsBuilder, tags) => tagsBuilder.AddTags(tags));
                break;

            case HerculesValueType.Int:
                builder.AddVector(key, vector.AsIntList);
                break;

            case HerculesValueType.Double:
                builder.AddVector(key, vector.AsDoubleList);
                break;

            case HerculesValueType.Bool:
                builder.AddVector(key, vector.AsBoolList);
                break;

            case HerculesValueType.Byte:
                builder.AddVector(key, vector.AsByteList);
                break;

            case HerculesValueType.Short:
                builder.AddVector(key, vector.AsShortList);
                break;

            case HerculesValueType.Float:
                builder.AddVector(key, vector.AsFloatList);
                break;

            case HerculesValueType.Null:
                builder.AddNull(key);
                break;

            case HerculesValueType.Vector:
                throw new NotSupportedException("Support of nested vectors is not implemented.");

            default:
                throw new ArgumentOutOfRangeException(nameof(vector.ElementType), vector.ElementType, "Unknown vector element type.");
            }

            return(builder);
        }