public static byte[] Serialize(JContainer item)
 {
     var stringWriter = new StringWriter();
     var writer = new JsonTextWriter(stringWriter);
     item.WriteTo(writer);
     return Encoding.UTF8.GetBytes(stringWriter.ToString());
 }

 public void FillWithJsonObject(JContainer dict, Scheme scheme)
 {
     Title = (string)dict["title"];
     Id = (string)dict["id"];
     Color = (Color)ColorConverter.ConvertFromString((string)dict["color"]);
     Points = (dict["points"]).Select(p => new Point((double)p[0], (double)p[1])).ToArray();
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="JTokenWriter"/> class writing to the given <see cref="JContainer"/>.
        /// </summary>
        /// <param name="container">The container being written to.</param>
        public JTokenWriter(JContainer container)
        {
            ValidationUtils.ArgumentNotNull(container, "container");

            _token = container;
            _parent = container;
        }

 private void AddParent(JContainer container)
 {
   if (this._parent == null)
     this._token = container;
   else
     this._parent.AddAndSkipParentCheck((JToken) container);
   this._parent = container;
 }

 public virtual void FillWithJsonObject(JContainer dict, Scheme scheme)
 {
     Title = (string)dict["title"];
     Room = scheme.Rooms.Single(r => r.Id.Equals(dict["room"]));
     QRCode = (string)dict[@"qr_code"];
     Image = (string)dict["image"];
     Visible = (bool)dict[@"visible"];
 }

        /**
         * @param uri
         * @param method Case-insensitive
         * @param bodyObject
         * @param responseObject output, the value would be JObject or JArray
         */
        private bool _SendHttpRequest(string uri, string method, JObject bodyObject, out JContainer responseObject)
        {
            responseObject = null;
            var url = APIEndPoint + BaseURL + @"/" + uri;

            // Set remote url and http method.
            HttpWebRequest request = (HttpWebRequest)WebRequest.Create(url);
            request.Method = method;

            // Set the content type header and http body.
            if(bodyObject != null){
                var body = JsonConvert.SerializeObject(bodyObject);
                if (body.Length != 0)
                {
                    request.ContentType = "application/json";
                    using (Stream requestStream = request.GetRequestStream())
                    using (StreamWriter writer = new StreamWriter(requestStream))
                    {
                        writer.Write(body);
                    }
                }
            }

            // Set the authorization id.
            string sAuth = "auth_id=" + AuthoId;
            request.Headers.Add("Authorization", sAuth);

            string responseData = "";
            try
            {
                // Send request
                System.Net.WebResponse response = (HttpWebResponse)request.GetResponse();
                responseData = new StreamReader(response.GetResponseStream()).ReadToEnd();

            }
            catch (WebException e)
            {
                HttpWebResponse response = (HttpWebResponse)e.Response;
                if (response != null)
                {
                    responseData = new StreamReader(response.GetResponseStream()).ReadToEnd();

                    response.Close();   // Releases the resources of the response.
                }
            }
            catch (Exception)
            {
                return false;
            }

            if (!string.IsNullOrEmpty(responseData))
            {
                var res = JsonConvert.DeserializeObject(responseData);
                responseObject = res as JContainer;
            }

            return true;
        }

    private void AddParent(JContainer container)
    {
      if (_parent == null)
        _token = container;
      else
        _parent.Add(container);

      _parent = container;
    }

 public static QueryAggregateDigestsRequest FromJObject(JContainer jObject)
 {
     var request = JsonConvert.DeserializeObject<QueryAggregateDigestsRequest>(jObject.ToString());
     if (request.Constraints == null || request.Buckets == null)
     {
         throw new ArgumentNullException();
     }
     return request;
 }

 public void FormatLinks(JContainer container, IEnumerable<Link> links, JsonSerializer serializer)
 {
     var jLinks = new JArray();
     foreach (var link in links)
     {
         jLinks.Add(JObject.FromObject(link, serializer));
     }
     container[_linksPropertyName] = jLinks;
 }

 public void FormatLinks(JContainer container, IEnumerable<Link> links, JsonSerializer serializer)
 {
     var jLinks = new JObject();
     foreach (var link in links)
     {
         jLinks[link.Rel] = JValue.CreateString(link.Href);
     }
     container[_linksPropertyName] = jLinks;
 }

        public static void AssertSchemaIsValid(JSchema jSchema, JContainer jContainer)
        {
            IList<string> messages;
            var isValid = jContainer.IsValid(jSchema, out messages);
            foreach (var message in messages)
            {
                Console.WriteLine(message);
            }

            Assert.IsTrue(isValid);
        }

 /// <summary>
 /// Parse the child Actions object that is part of the Tropo Result object. 
 /// </summary>
 /// <param name="actions">Actions - is either an Object or an Array.</param>
 /// <returns></returns>
 public static JContainer parseActions(JContainer actions)
 {
     JTokenType type = actions.Type;
     if (type == JTokenType.Array)
     {
         return JArray.Parse(actions.ToString());
     }
     else
     {
         return parseObject(actions);
     }
 }

 private bool ReadInto(JContainer c)
 {
     JToken firstChild = c.First;
       if (firstChild == null)
       {
     return SetEnd(c);
       }
       else
       {
     SetToken(firstChild);
     _current = firstChild;
     _parent = c;
     return true;
       }
 }

 private JsonToken? GetEndToken(JContainer c)
 {
     switch (c.Type)
       {
     case JsonTokenType.Object:
       return JsonToken.EndObject;
     case JsonTokenType.Array:
       return JsonToken.EndArray;
     case JsonTokenType.Constructor:
       return JsonToken.EndConstructor;
     case JsonTokenType.Property:
       return null;
     default:
       throw MiscellaneousUtils.CreateArgumentOutOfRangeException("Type", c.Type, "Unexpected JContainer type.");
       }
 }

        /// <summary>
        /// Generates a collection of patterns for the specified <see cref="JContainer"/>.
        /// </summary>
        public PatternCollection GeneratePatterns(JContainer root, int desiredCount, bool skipValues = true)
        {
            var descendants = root.DescendantsAndSelf().ToArray();
            descendants.Shuffle(random);

            if (skipValues)
                descendants = descendants.Where(x => x is JObject || x is JArray).ToArray();

            var patterns = descendants
                .Select(x => x.Path)
                .Where(x => !string.IsNullOrWhiteSpace(x))
                .Take(desiredCount)
                .Select(x => (random.NextBool() ? "!" : "") + x)
                .Select(AddWildcards)
                .ToArray();

            return PatternCollection.Parse(patterns);
        }

        private bool DoesParentHaveSaidKey(JContainer container, string tokenPath)
        {
            if (container == null)
                return false;

            var result = DoesParentHaveSaidKey(container.Parent, tokenPath);

            var key = tokenPath.Split('.').LastOrDefault();

            foreach (var desc in container.Values())
            {
                var descPath = desc.Path.Split('.');
                if (descPath.Length < tokenPath.Split('.').Length && descPath.Last() == key) {
                    result = result || true;
                    break;
                }
            }
            return result;
        }

 private IEnumerable<Source> ReadSources(JContainer json)
 {
     var sources =  new List<Source>();
     var items = json.ToObject<List<JObject>>();
     foreach (var item in items)
     {
         var source = new Source()
         {
             Id = item["id"].Value<int>(),
             Title = item["title"].ToString(),
             Spout = item["spout"].ToString(),
             Params = item["params"].ToObject<Dictionary<string, string>>(),
             Error = item["error"].ToString(),
             Favicon = item["icon"].ToString(),
             Tags = new List<string>(item["tags"].ToString().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
         };
         sources.Add(source);
     }
     return sources;
 }

        public void FillWithJsonObject(JContainer dict, Scheme scheme)
        {
            Rooms = dict["rooms"].Select(r =>
            {
                Room room = new Room();
                room.FillWithJsonObject((JContainer)r, scheme);
                return room;
            }).ToArray();

            Items = dict["items"].Select(i =>
            {
                Item item;
                string locType = (string)i["location_type"];
                if (locType.Equals("room"))
                    item = new RoomItem();
                else
                    item = new CoordinateItem();
                item.FillWithJsonObject((JContainer)i, scheme);
                return item;
            }).ToArray();
        }

        public HttpResponseMessage DynExecute(string sp, JContainer requestBody)
        {
            if (requestBody == null)
                return Execute(sp, null);

            JObject parameters = requestBody as JObject;

            if (parameters != null)
                return Execute(sp, parameters.ToObject<Dictionary<string, object>>());

            JArray bulkParameters = requestBody as JArray;

            if (bulkParameters != null)
            {
                List<Dictionary<string, object>> listOfDicts = bulkParameters.ToObject<List<Dictionary<string, object>>>();

                if (listOfDicts != null && listOfDicts.Count > 0)
                    return BulkExecute(sp, listOfDicts);
                else
                    return Request.CreateResponse(HttpStatusCode.NoContent);
            }

            return Request.CreateResponse(HttpStatusCode.BadRequest);
        }

 public JObjectValueProvider(JContainer jcontainer)
 {
     _jcontainer = jcontainer;
 }