/// <summary>
        /// 
        /// </summary>
        /// <param name="o"></param>
        /// <param name="typeName"></param>
        /// <param name="variableNameInLowerCamelCase"></param>
        /// <param name="defaultValue">Can be null</param>
        /// <param name="doesWriteGetter"></param>
        /// <param name="getterAccessibility">Can be null</param>
        /// <param name="doesWriteSetter"></param>
        /// <param name="setterAccessibility">Can be null</param>
        private static void WritePropertyImpl(ICodeWriter o, string typeName, string variableNameInLowerCamelCase, string defaultValue, bool doesWriteGetter, string getterAccessibility, bool doesWriteSetter, string setterAccessibility)
        {
            string getterAccessibilityWithSpace = "";
            string setterAccessibilityWithSpace = "";
            string defaultValueWithAssignMark = "";

            if (getterAccessibility != null)
            {
                getterAccessibilityWithSpace = getterAccessibility + " ";
            }
            if (setterAccessibility != null)
            {
                setterAccessibilityWithSpace = setterAccessibility + " ";
            }
            if (defaultValue != null)
            {
                defaultValueWithAssignMark = " = " + defaultValue;
            }

            string variableNameInUpperCamelCase = GetVariableNameInUpperCamelCase(variableNameInLowerCamelCase);

            o.BeginBlock("public {0} {1} {{", typeName, variableNameInUpperCamelCase);
            if (doesWriteGetter)
            {
                o.WriteLine("{0}get {{ return {1}; }}", getterAccessibilityWithSpace, variableNameInLowerCamelCase);
            }
            if (doesWriteSetter)
            {
                o.WriteLine("{0}set {{ {1} = value; }}", setterAccessibilityWithSpace, variableNameInLowerCamelCase);
            }
            o.EndBlock("}");
            o.WriteLine("{0} {1}{2};", typeName, variableNameInLowerCamelCase, defaultValueWithAssignMark);
        }

#pragma warning disable 1591
        public override void Write(ICodeWriter writer)
        {
            base.Write(writer);
            if( _extensions.Count > 0 )
            {
                writer.Newline();
                IndentMultiple(writer, 3);
                writer.WriteWithIndentation(".extend({{");
                writer.Newline();
                writer.Indent();

                foreach (var extension in _extensions)
                {
                    if (extension != _extensions[0])
                    {
                        writer.Write(",");
                        writer.Newline();
                    }
                    writer.WriteWithIndentation("{0} : {1}", extension.Name, extension.Options);
                }
                writer.Unindent();
                writer.Newline();
                writer.WriteWithIndentation("}})");
                UnindentMultiple(writer, 3);
            }
        }

 public static void WriteAccessor(ICodeWriter o, string typeName, string variableNameInLowerCamelCase)
 {
     o.BeginBlock("public {0} {1} {{", typeName, GetVariableNameInUpperCamelCase(variableNameInLowerCamelCase));
     o.WriteLine("get {{ return {0}; }}", variableNameInLowerCamelCase);
     o.WriteLine("set {{ {0} = value; }}", variableNameInLowerCamelCase);
     o.EndBlock("}");
 }

        public void Render(ICodeWriter renderer)
        {
            if (!SingleLine)
            {
                renderer.WriteLine("");
                renderer.WriteLine("{");
                renderer.PushIndent();

                foreach (ICode codeLine in codes)
                {
                    renderer.WriteLine("{0}", codeLine);
                }

                renderer.PopIndent();
                renderer.WriteLine("}");
            }
            else
            {
                renderer.Write("{ ");

                foreach (ICode codeLine in codes)
                {
                    renderer.Write("{0}", codeLine);
                }

                renderer.Write(" }");
            }
        }

#pragma warning disable 1591
        public override void Write(ICodeWriter writer)
        {
            var childIndex = 0;
            var numberOfChildren = Children.Count;

            writer.Write("{{");

            if (numberOfChildren > 0)
            {
                writer.Newline();
                writer.Indent();

                foreach (var child in Children)
                {
                    child.Write(writer);
                    childIndex++;

                    if (childIndex > 0 && childIndex < numberOfChildren)
                        writer.Write(",");
                    writer.Newline();
                }

                writer.Unindent();
                writer.WriteWithIndentation("}}");
            }
            else
            {
                writer.Write("}}");
            }
        }

 public void Write(ICodeWriter o)
 {
     o.WriteLine("[Transient]");
     o.BeginBlock("internal sealed class {0} : IEventFactory {{", factoryName);
     WriteRecreateEvent(o);
     o.EndBlock("}");
 }

#pragma warning disable 1591
        public override void Write(ICodeWriter writer)
        {
            writer.WriteWithIndentation("Bifrost.namespace(\"{0}\", ", Name);
            Content.Write(writer);
            writer.WriteWithIndentation(");");
            writer.Newline();
        }

        public override void Render(ICodeWriter renderer)
        {
            renderer.Write("{0}<", name);

            string placeholders = CodeUtils.Placeholders(GenericArgumentTypes.Count());
            renderer.Write(string.Format("{0}>", placeholders), GenericArgumentTypes.ToArray());
        }

#pragma warning disable 1591
        public override void Write(ICodeWriter writer)
        {
            writer.WriteWithIndentation("{0} = ", Name);
            if( Value != null ) Value.Write(writer);
            writer.Write(";");
            writer.Newline();
        }

 private void WriteEvents(ICodeWriter o)
 {
     foreach (EventInfo ei in eventInfos)
     {
         o.WriteLine("public event GenericEventHandler<{0}> {1};", ei.Type.Name, GetHandlerName(ei.Type.Name));
     }
 }

 private static void WriteSerializeFieldStatementRecursive(ICodeWriter o, bool writeToBitstream, Type variableType, string variableName)
 {
     if (variableType.IsArray)
     {
         Type elemType = variableType.GetElementType();
         if (writeToBitstream)
         {
             WriteStreamWriteStatement(o, variableName + ".Length");
             o.BeginBlock("for (int i = 0; i < {0}.Length; i++) {{", variableName);
             WriteSerializeFieldStatementRecursive(o, writeToBitstream, elemType, variableName + "[i]");
             o.EndBlock("}");
         }
         else
         {
             string lengthVariableName = "_" + variableName + "Length";
             o.WriteLine("int {0};", lengthVariableName);
             WriteStreamReadStatement(o, "out", lengthVariableName);
             o.WriteLine("{0} = new {1}[{2}];", variableName, elemType.ToString(), lengthVariableName);
             o.BeginBlock("for (int i = 0; i < {0}; i++) {{", lengthVariableName);
             WriteSerializeFieldStatementRecursive(o, writeToBitstream, elemType, variableName + "[i]");
             o.EndBlock("}");
         }
     }
     else
     {
         WriteSerializeNonCollectionStatement(o, writeToBitstream, variableType, variableName);
     }
 }

 public override void Render(ICodeWriter renderer)
 {
     foreach (AttributeStatement attribute in attributes)
     {
         renderer.Write("{0}", attribute);
     }
     base.Render(renderer);
 }

 public static void WriteSingleton(ICodeWriter o, string className)
 {
     o.WriteLine("private static {0} instance = new {0}();", className);
     o.BeginBlock("public static {0} Instance {{", className);
     o.WriteLine("get { return instance; }");
     o.EndBlock("}");
     o.WriteLine("private {0}() {{ }}", className);
 }

 public override void Render(ICodeWriter renderer)
 {
     if(AccessModifier != null)
     {
         renderer.Write("{0} ", AccessModifier);
     }
     renderer.Write(snippet, name, statement);
 }

 public void Write(ICodeWriter o)
 {
     o.WriteLine("[Transient]");
     o.BeginBlock("internal sealed class {0} : IEventHandlers {{", handlersName);
     WriteCallHandler(o);
     WriteEvents(o);
     o.EndBlock("}");
 }

 public override void Write(ICodeWriter o)
 {
     WriteUsing(o);
     foreach (IGenerator generator in generators)
     {
         generator.Write(o);
     }
 }

 public override void Render(ICodeWriter renderer)
 {
     foreach (AttributeStatement attribute in attributes)
     {
         renderer.Write("{0} ", attribute);
     }
     renderer.Write(snippet, AccessModifier, Modifier, ReturnType, name, parameterList, body);
 }

 public override void Render(ICodeWriter renderer)
 {
     renderer.Write("new {0}", type);
     renderer.Write(string.Format("({0})", CodeUtils.Placeholders(parameters.Count)), parameters.ToArray());
     if (initializer.HasInitiCode())
     {
         renderer.Write("{0}", initializer);
     }
 }

        public override void Render(ICodeWriter renderer)
        {
            var bracedCode = new BracedCode(statements)
                                 {
                                     SingleLine = SingleLine
                                 };

            bracedCode.Render(renderer);
        }

 public override void Render(ICodeWriter renderer)
 {
     renderer.Write("{0} {1}({2})", AccessModifier, type.GetName(), parameterList);
     if (CallBaseCtor)
     {
         renderer.Write(string.Format(" : base({0})", CodeUtils.Placeholders(baseParameters.Count)), baseParameters.ToArray());
     }
     renderer.Write("{0}", body);
 }