/// <summary>
 /// Initializes a new instance of the DateTimeSerializationOptions class.
 /// </summary>
 /// <param name="kind">The DateTimeKind (Local, Unspecified or Utc).</param>
 /// <param name="representation">The external representation.</param>
 public DateTimeSerializationOptions(
     DateTimeKind kind,
     BsonType representation
 ) {
     this.kind = kind;
     this.representation = representation;
 }

        public int CalculateSize(BsonType t_Type, List<object> value)
        {
            switch (t_Type)
            {
                case BsonType.Object:
                    {
                        foreach (var p in value)
                        {
                            //Console.WriteLine(new { p });

                            Native.document.body += new IHTMLPre { new { p } };

                        }
                        return -1;
                    }

                case BsonType.Integer:
                    return 4;
                case BsonType.Long:
                    return 8;
                case BsonType.Number:
                    return 8;
                case BsonType.Boolean:
                    return 1;
                case BsonType.Null:
                case BsonType.Undefined:
                    return 0;
                case BsonType.Date:
                    return 8;
                default:
                    return 12;
            }
        }

 public CollectionProperty(string name, BsonType type, string fullName)
 {
     _name = name;
     _type = type;
     _fullName = fullName;
     Children = new Dictionary<string, CollectionProperty>();
 }

        public static IBehavior Find(BsonType bsonType)
        {
            IBehavior behavior;

            return DsonBehaviors.TryGetValue(bsonType, out behavior)
                ? behavior
                : null;
        }

 /// <summary>
 /// Initializes a new instance of the RepresentationSerializationOptions class.
 /// </summary>
 /// <param name="representation">The external representation.</param>
 /// <param name="allowOverflow">Whether to allow overflow.</param>
 /// <param name="allowTruncation">Whether to allow truncation.</param>
 public RepresentationSerializationOptions(
     BsonType representation,
     bool allowOverflow,
     bool allowTruncation
 ) {
     this.representation = representation;
     this.allowOverflow = allowOverflow;
     this.allowTruncation = allowTruncation;
 }

 // constructors
 internal JsonReaderBookmark(BsonReaderState state, BsonType currentBsonType, string currentName, JsonReaderContext context, JsonToken currentToken, BsonValue currentValue, JsonToken pushedToken, int position)
     : base(state, currentBsonType, currentName)
 {
     _context = context.Clone();
     _currentToken = currentToken;
     _currentValue = currentValue;
     _pushedToken = pushedToken;
     _position = position;
 }

 public void ReturnToBookmark(PBBsonReaderBookmark bookmark)
 {
     _reader.ReturnToBookmark(bookmark.Bookmark);
     _type = bookmark.Type;
     _name = bookmark.Name;
     _bsonType = bookmark.BsonType;
     _value = bookmark.Value;
     _indent = bookmark.Indent;
     _indentString = bookmark.IndentString;
 }

 protected BsonReaderBookmark(
     BsonReadState state,
     BsonType currentBsonType,
     string currentName
 )
 {
     this.state = state;
     this.currentBsonType = currentBsonType;
     this.currentName = currentName;
 }

 internal BsonDocumentReaderBookmark(
     BsonDocumentReaderContext context,
     BsonReadState state,
     BsonType currentBsonType
 )
 {
     this.context = context.Clone();
     this.state = state;
     this.currentBsonType = currentBsonType;
 }

 public BsonBinaryReader(
     BsonBuffer buffer,
     BsonBinaryReaderSettings settings
 ) {
     this.buffer = buffer ?? new BsonBuffer();
     this.disposeBuffer = buffer == null; // only call Dispose if we allocated the buffer
     this.settings = settings;
     context = null;
     state = BsonReadState.Initial;
     currentBsonType = BsonType.Document;
 }

 // constructors
 /// <summary>
 /// Initializes a new instance of the <see cref="EnumRepresentationConvention" /> class.
 /// </summary>  
 /// <param name="representation">The serialization representation. 0 is used to detect representation
 /// from the enum itself.</param>
 public EnumRepresentationConvention(BsonType representation)
 {
     if (!((representation == 0) ||
         (representation == BsonType.String) ||
         (representation == BsonType.Int32) ||
         (representation == BsonType.Int64)))
     {
         throw new ArgumentException("Enums can only be represented as String, Int32, Int64 or the type of the enum");
     }
     _representation = representation;
 }

 // constructors
 internal BsonDocumentReaderBookmark(
     BsonReaderState state,
     BsonType currentBsonType,
     string currentName,
     BsonDocumentReaderContext context,
     BsonValue currentValue)
     : base(state, currentBsonType, currentName)
 {
     _context = context.Clone();
     _currentValue = currentValue;
 }

 public void TestConvention(BsonType value)
 {
     var convention = new EnumRepresentationConvention(value);
     var classMap = new BsonClassMap<TestClass>();
     var nonEnumMemberMap = classMap.MapMember(x => x.NonEnum);
     var defaultEnumMemberMap = classMap.MapMember(x => x.DefaultEnum);
     var changedEnumMemberMap = classMap.MapMember(x => x.ChangedRepresentationEnum);
     convention.Apply(nonEnumMemberMap);
     convention.Apply(changedEnumMemberMap);
     Assert.AreEqual(value, ((IRepresentationConfigurable)(changedEnumMemberMap.GetSerializer())).Representation);
 }

 // constructors
 internal BsonBinaryReaderBookmark(
     BsonReaderState state,
     BsonType currentBsonType,
     string currentName,
     BsonBinaryReaderContext context,
     int position)
     : base(state, currentBsonType, currentName)
 {
     _context = context.Clone();
     _position = position;
 }

 internal BsonBinaryReaderBookmark(
     BsonBinaryReaderContext context,
     BsonReadState state,
     BsonType currentBsonType,
     int position
 )
 {
     this.context = context;
     this.state = state;
     this.currentBsonType = currentBsonType;
     this.position = position;
 }

 public void TestConvention(BsonType value)
 {
     var convention = new EnumRepresentationConvention(value);
     var classMap = new BsonClassMap<TestClass>();
     var nonEnumMemberMap = classMap.MapMember(x => x.NonEnum);
     var defaultEnumMemberMap = classMap.MapMember(x => x.DefaultEnum);
     var changedEnumMemberMap = classMap.MapMember(x => x.ChangedRepresentationEnum);
     convention.Apply(nonEnumMemberMap);
     convention.Apply(changedEnumMemberMap);
     Assert.IsNull(nonEnumMemberMap.SerializationOptions);
     Assert.IsNull(defaultEnumMemberMap.SerializationOptions);
     Assert.AreEqual(value, ((RepresentationSerializationOptions)changedEnumMemberMap.SerializationOptions).Representation);
 }

        public int CalculateSize(BsonType t_Type, List<object> value)
        {
            //TestSwitchForEach.BsonBinaryWriter <0000> nop
            //TestSwitchForEach.BsonBinaryWriter <004a> nop
            //TestSwitchForEach.BsonBinaryWriter <0053> br.s, to be optimized away
            //enter finally { mname = <0053> br.s, to be optimized away.try }
            //TestSwitchForEach.BsonBinaryWriter <006b> ldloca.s
            //enter finally { mname = <006b> ldloca.s.try }
            //TestSwitchForEach.BsonBinaryWriter <0055> ldloca.s
            //{ p = { x = 1 } }
            //enter finally { mname = <0055> ldloca.s.try }
            //TestSwitchForEach.BsonBinaryWriter <006b> ldloca.s
            //enter finally { mname = <006b> ldloca.s.try }
            //TestSwitchForEach.BsonBinaryWriter <0055> ldloca.s
            //{ p = { x = 2 } }
            //enter finally { mname = <0055> ldloca.s.try }
            //TestSwitchForEach.BsonBinaryWriter <006b> ldloca.s
            //enter finally { mname = <006b> ldloca.s.try }
            //TestSwitchForEach.BsonBinaryWriter <0078> leave.s, to be optimized away
            //enter finally { mname = <0078> leave.s, to be optimized away.try }
            //TestSwitchForEach.BsonBinaryWriter <0089> nop
            //TestSwitchForEach.BsonBinaryWriter <00ab> ldloc.1

            switch (t_Type)
            {
                case BsonType.Object:
                    {
                        foreach (var p in value)
                        {
                            Console.WriteLine(new { p });
                        }
                        return -1;
                    }

                case BsonType.Integer:
                    return 4;
                case BsonType.Long:
                    return 8;
                case BsonType.Number:
                    return 8;
                case BsonType.Boolean:
                    return 1;
                case BsonType.Null:
                case BsonType.Undefined:
                    return 0;
                case BsonType.Date:
                    return 8;
                default:
                    return 12;
            }
        }

        // https://sites.google.com/a/jsc-solutions.net/backlog/knowledge-base/2014/201405/20140524

        //public static int WriteEscapedJavaScriptString(BsonType t_Type, ref  char[] writeBuffer)
        //public static int WriteEscapedJavaScriptString(BsonType t_Type, char[] writeBuffer)



        public int WriteEscapedJavaScriptString(
            BsonType t_Type,
            char[] writeBuffer,
            // why is this not made byref?
            foo foo)
        {
            foo foocopy = foo;

            // X:\jsc.svn\examples\rewrite\Test\TestSwitchForEach\TestSwitchForEach\Program.cs

            switch (t_Type)
            {
                case BsonType.Object:
                    {
                        //foreach (var p in writeBuffer)
                        foreach (var p in foo.writeBuffer)
                        {
                            Console.WriteLine(new { p });
                        }
                        return -1;
                    }

                case BsonType.Integer:
                    return 4;
                case BsonType.Long:
                    return 8;
                case BsonType.Number:
                    return 8;
                case BsonType.Boolean:
                    return 1;
                case BsonType.Null:
                case BsonType.Undefined:
                    return 0;
                case BsonType.Date:
                    return 8;
                default:
                    return 12;
            }
        }

 /// <summary>
 /// Verifies the current state and BsonType of the reader.
 /// </summary>
 /// <param name="methodName">The name of the method calling this one.</param>
 /// <param name="requiredBsonType">The required BSON type.</param>
 protected void VerifyBsonType(string methodName, BsonType requiredBsonType)
 {
     if (_state == BsonReaderState.Initial || _state == BsonReaderState.ScopeDocument || _state == BsonReaderState.Type)
     {
         ReadBsonType();
     }
     if (_state == BsonReaderState.Name)
     {
         // ignore name
         SkipName();
     }
     if (_state != BsonReaderState.Value)
     {
         ThrowInvalidState(methodName, BsonReaderState.Value);
     }
     if (_currentBsonType != requiredBsonType)
     {
         var message = string.Format(
             "{0} can only be called when CurrentBsonType is {1}, not when CurrentBsonType is {2}.",
             methodName, requiredBsonType, _currentBsonType);
         throw new InvalidOperationException(message);
     }
 }

 private void AddValue(object value, BsonType type)
 {
     AddToken(new BsonValue(value, type));
 }