/// <summary>
        /// Reads a file representing a grain state object.
        /// </summary>
        /// <param name="collectionName">The type of the grain state object.</param>
        /// <param name="key">The grain id string.</param>
        /// <returns>Completion promise for this operation.</returns>
        public async Task <string> Read(string collectionName, string key)
        {
            var collection = GetCollection(collectionName);

            if (collection == null)
            {
                return(null);
            }

            var builder = Builders <BsonDocument> .Filter.Eq("key", key);

            var existing = await collection.Find(builder).FirstOrDefaultAsync();

            if (existing == null)
            {
                return(null);
            }

            existing.Remove("_id");
            existing.Remove("key");

            var strwrtr = new System.IO.StringWriter();
            var writer  = new MongoDB.Bson.IO.JsonWriter(strwrtr, new MongoDB.Bson.IO.JsonWriterSettings());

            MongoDB.Bson.Serialization.BsonSerializer.Serialize(writer, existing);

            return(strwrtr.ToString());
        }
        static int __CreateInstance(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                if (LuaAPI.lua_gettop(L) == 2 && translator.Assignable <System.IO.TextWriter>(L, 2))
                {
                    System.IO.TextWriter _writer = (System.IO.TextWriter)translator.GetObject(L, 2, typeof(System.IO.TextWriter));

                    MongoDB.Bson.IO.JsonWriter gen_ret = new MongoDB.Bson.IO.JsonWriter(_writer);
                    translator.Push(L, gen_ret);

                    return(1);
                }
                if (LuaAPI.lua_gettop(L) == 3 && translator.Assignable <System.IO.TextWriter>(L, 2) && translator.Assignable <MongoDB.Bson.IO.JsonWriterSettings>(L, 3))
                {
                    System.IO.TextWriter _writer = (System.IO.TextWriter)translator.GetObject(L, 2, typeof(System.IO.TextWriter));
                    MongoDB.Bson.IO.JsonWriterSettings _settings = (MongoDB.Bson.IO.JsonWriterSettings)translator.GetObject(L, 3, typeof(MongoDB.Bson.IO.JsonWriterSettings));

                    MongoDB.Bson.IO.JsonWriter gen_ret = new MongoDB.Bson.IO.JsonWriter(_writer, _settings);
                    translator.Push(L, gen_ret);

                    return(1);
                }
            }
            catch (System.Exception gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
            }
            return(LuaAPI.luaL_error(L, "invalid arguments to MongoDB.Bson.IO.JsonWriter constructor!"));
        }
Example #3
0
        /// <summary>
        /// Reads a file representing a grain state object.
        /// </summary>
        /// <param name="collectionName">The type of the grain state object.</param>
        /// <param name="key">The grain id string.</param>
        /// <returns>Completion promise for this operation.</returns>
        public Task <string> Read(string collectionName, string key)
        {
            var collection = GetCollection(collectionName);

            if (collection == null)
            {
                return(Task.FromResult <string>(null));
            }

            var query    = Query.EQ("key", key);
            var existing = collection.FindOne(query);

            if (existing == null)
            {
                return(Task.FromResult <string>(null));
            }

            existing.Remove("_id");
            existing.Remove("key");

            var strwrtr = new System.IO.StringWriter();
            var writer  = new MongoDB.Bson.IO.JsonWriter(strwrtr, new MongoDB.Bson.IO.JsonWriterSettings());

            MongoDB.Bson.Serialization.BsonSerializer.Serialize <BsonDocument>(writer, existing);

            return(Task.FromResult(strwrtr.ToString()));
        }
        private static string DeserializeBsonDocumentToJson(IMongoCollection <BsonDocument> collection, BsonDocument doc)
        {
            var stringWriter = new StringWriter();
            var jsonWriter   = new MongoDB.Bson.IO.JsonWriter(stringWriter);
            var context      = BsonSerializationContext.CreateRoot(jsonWriter);

            collection.DocumentSerializer.Serialize(context, doc);
            string result = stringWriter.ToString();

            return(result);
        }
        static int _g_get_Settings(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);

                MongoDB.Bson.IO.JsonWriter gen_to_be_invoked = (MongoDB.Bson.IO.JsonWriter)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.Settings);
            } catch (System.Exception gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
            }
            return(1);
        }
Example #6
0
        private static string ConvertChangeStreamBsonDocumentToJson(ChangeStreamDocument <BsonDocument> changeStreamDocument)
        {
            string json;
            var    subject = new ChangeStreamDocumentSerializer <BsonDocument>(BsonDocumentSerializer.Instance);

            using (var textWriter = new StringWriter())
                using (var writer = new MongoDB.Bson.IO.JsonWriter(textWriter))
                {
                    {
                        var context = BsonSerializationContext.CreateRoot(writer);
                        subject.Serialize(context, changeStreamDocument);
                        json = textWriter.ToString();
                    }
                }
            return(json);
        }
        static int _m_WriteUndefined(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


                MongoDB.Bson.IO.JsonWriter gen_to_be_invoked = (MongoDB.Bson.IO.JsonWriter)translator.FastGetCSObj(L, 1);



                {
                    gen_to_be_invoked.WriteUndefined(  );



                    return(0);
                }
            } catch (System.Exception gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
            }
        }
        static int _m_WriteTimestamp(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


                MongoDB.Bson.IO.JsonWriter gen_to_be_invoked = (MongoDB.Bson.IO.JsonWriter)translator.FastGetCSObj(L, 1);



                {
                    long _value = LuaAPI.lua_toint64(L, 2);

                    gen_to_be_invoked.WriteTimestamp(_value);



                    return(0);
                }
            } catch (System.Exception gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
            }
        }
        static int _m_WriteRegularExpression(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


                MongoDB.Bson.IO.JsonWriter gen_to_be_invoked = (MongoDB.Bson.IO.JsonWriter)translator.FastGetCSObj(L, 1);



                {
                    MongoDB.Bson.BsonRegularExpression _regex = (MongoDB.Bson.BsonRegularExpression)translator.GetObject(L, 2, typeof(MongoDB.Bson.BsonRegularExpression));

                    gen_to_be_invoked.WriteRegularExpression(_regex);



                    return(0);
                }
            } catch (System.Exception gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
            }
        }
        static int _m_WriteJavaScriptWithScope(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


                MongoDB.Bson.IO.JsonWriter gen_to_be_invoked = (MongoDB.Bson.IO.JsonWriter)translator.FastGetCSObj(L, 1);



                {
                    string _code = LuaAPI.lua_tostring(L, 2);

                    gen_to_be_invoked.WriteJavaScriptWithScope(_code);



                    return(0);
                }
            } catch (System.Exception gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
            }
        }
        static int _m_WriteDecimal128(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


                MongoDB.Bson.IO.JsonWriter gen_to_be_invoked = (MongoDB.Bson.IO.JsonWriter)translator.FastGetCSObj(L, 1);



                {
                    MongoDB.Bson.Decimal128 _value; translator.Get(L, 2, out _value);

                    gen_to_be_invoked.WriteDecimal128(_value);



                    return(0);
                }
            } catch (System.Exception gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
            }
        }
        static int _m_WriteBinaryData(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);


                MongoDB.Bson.IO.JsonWriter gen_to_be_invoked = (MongoDB.Bson.IO.JsonWriter)translator.FastGetCSObj(L, 1);



                {
                    MongoDB.Bson.BsonBinaryData _binaryData = (MongoDB.Bson.BsonBinaryData)translator.GetObject(L, 2, typeof(MongoDB.Bson.BsonBinaryData));

                    gen_to_be_invoked.WriteBinaryData(_binaryData);



                    return(0);
                }
            } catch (System.Exception gen_e) {
                return(LuaAPI.luaL_error(L, "c# exception:" + gen_e));
            }
        }
        /// <summary>
        /// Reads a file representing a grain state object.
        /// </summary>
        /// <param name="collectionName">The type of the grain state object.</param>
        /// <param name="key">The grain id string.</param>
        /// <returns>Completion promise for this operation.</returns>
        public Task<string> Read(string collectionName, string key)
        {
            var collection = GetCollection(collectionName);
            if (collection == null)
                return Task.FromResult<string>(null);

            var query = Query.EQ("key", key);
            var existing = collection.FindOne(query);

            if (existing == null)
                return Task.FromResult<string>(null);

            existing.Remove("_id");
            existing.Remove("key");

            var strwrtr = new System.IO.StringWriter();
            var writer = new MongoDB.Bson.IO.JsonWriter(strwrtr, new MongoDB.Bson.IO.JsonWriterSettings());
            MongoDB.Bson.Serialization.BsonSerializer.Serialize<BsonDocument>(writer, existing);

            return Task.FromResult(strwrtr.ToString());
        }
        //---------------------------------------------------------------------
        /// <summary>
        /// Reads a file representing a grain state object.
        /// </summary>
        /// <param name="collectionName">The type of the grain state object.</param>
        /// <param name="key">The grain id string.</param>
        /// <returns>Completion promise for this operation.</returns>
        public async Task<string> Read(string collectionName, string key)
        {
            var collection = GetCollection(collectionName);
            if (collection == null) return null;

            var builder = Builders<BsonDocument>.Filter.Eq("key", key);

            var existing = await collection.Find(builder).FirstOrDefaultAsync();
            if (existing == null) return null;

            existing.Remove("_id");
            existing.Remove("key");

            var strwrtr = new System.IO.StringWriter();
            var writer = new MongoDB.Bson.IO.JsonWriter(strwrtr, new MongoDB.Bson.IO.JsonWriterSettings());
            MongoDB.Bson.Serialization.BsonSerializer.Serialize(writer, existing);

            return strwrtr.ToString();
        }