internal WrappedSerializer(Serialization.DataFormat dataFormat, string streamName, TextWriter output) : base(dataFormat, streamName)
		{
			this.firstCall = true;
			this.textWriter = output;
			Serialization.DataFormat dataFormat1 = this.format;
			switch (dataFormat1)
			{
				case Serialization.DataFormat.Text:
				{
					return;
				}
				case Serialization.DataFormat.XML:
				{
					XmlWriterSettings xmlWriterSetting = new XmlWriterSettings();
					xmlWriterSetting.CheckCharacters = false;
					xmlWriterSetting.OmitXmlDeclaration = true;
					this.xmlWriter = XmlWriter.Create(this.textWriter, xmlWriterSetting);
					this.xmlSerializer = new Serializer(this.xmlWriter);
					return;
				}
				default:
				{
					return;
				}
			}
		}

		public override void WriteInstance( Serialization.MaterialSerializer ser, SubRenderState subRenderState,
		                                    Graphics.Pass srcPass, Graphics.Pass dstPass )
		{
			//TODO
			//ser.WriteAttribute(4, "transform_stage");
			//ser.WriteValue("ffp");
		}

        public ObjectReferencePropertyTemplate(Arebis.CodeGeneration.IGenerationHost _host, IZetboxContext ctx, Serialization.SerializationMembersList serializationList, string moduleNamespace, string ownInterface, string name, string implName, string eventName, string fkBackingName, string fkGuidBackingName, string referencedInterface, string referencedImplementation, string associationName, string targetRoleName, string positionPropertyName, string inverseNavigatorName, bool inverseNavigatorIsList, bool eagerLoading, bool relDataTypeExportable, bool callGetterSetterEvents, bool isCalculated, bool disableExport)
            : base(_host)
        {
			this.ctx = ctx;
			this.serializationList = serializationList;
			this.moduleNamespace = moduleNamespace;
			this.ownInterface = ownInterface;
			this.name = name;
			this.implName = implName;
			this.eventName = eventName;
			this.fkBackingName = fkBackingName;
			this.fkGuidBackingName = fkGuidBackingName;
			this.referencedInterface = referencedInterface;
			this.referencedImplementation = referencedImplementation;
			this.associationName = associationName;
			this.targetRoleName = targetRoleName;
			this.positionPropertyName = positionPropertyName;
			this.inverseNavigatorName = inverseNavigatorName;
			this.inverseNavigatorIsList = inverseNavigatorIsList;
			this.eagerLoading = eagerLoading;
			this.relDataTypeExportable = relDataTypeExportable;
			this.callGetterSetterEvents = callGetterSetterEvents;
			this.isCalculated = isCalculated;
			this.disableExport = disableExport;

        }

 /// <summary>
 /// Overrides the existing values
 /// </summary>
 /// <param name="declaration"></param>
 public void Override(Serialization.StyleDeclaration declaration)
 {
     foreach (StyleProperty property in _styleSheetDeclaration.Properties)
     {
         _cached[property.Name] = property.Value;
     }
 }

        private static void Call(Arebis.CodeGeneration.IGenerationHost host,
            IZetboxContext ctx,
            Serialization.SerializationMembersList serializationList,
            Property prop, bool hasPersistentOrder, bool isList,
            string collectionWrapperClass,
            string listWrapperClass)
        {
            if (prop == null) { throw new ArgumentNullException("prop"); }
            if (!isList) { throw new ArgumentOutOfRangeException("prop", "prop must be a List-valued property"); }

            string name = prop.Name;
            string backingName = "_" + name;
            string backingCollectionType = (hasPersistentOrder ? listWrapperClass : collectionWrapperClass);

            string exposedCollectionInterface = hasPersistentOrder ? "IList" : "ICollection";

            string thisInterface = prop.ObjectClass.Name;
            string referencedType = prop.GetElementTypeString();
            string referencedCollectionEntry = prop.GetCollectionEntryFullName();
            string referencedCollectionEntryImpl = referencedCollectionEntry + host.Settings["extrasuffix"] + Zetbox.API.Helper.ImplementationSuffix;

            string providerCollectionType = "ObservableCollection<" + referencedCollectionEntryImpl + ">";
            string underlyingCollectionName = "_" + name + "Collection";

            string moduleNamespace = prop.Module.Namespace;

            Call(
                host, ctx, serializationList,
                name, backingName, backingCollectionType, exposedCollectionInterface,
                thisInterface, referencedType,
                referencedCollectionEntry, referencedCollectionEntryImpl,
                providerCollectionType, underlyingCollectionName, !hasPersistentOrder,
                moduleNamespace,
                prop.DisableExport == true);
        }

        private void InternalNetSerialize(Serialization.CrySerialize serialize, int aspect, byte profile, int flags)
        {
            // var serialize = new Serialization.CrySerialize();
            //serialize.Handle = handle;

            NetSerialize(serialize, aspect, profile, flags);
        }

        public static void Main(string[] args)
        {
            var twitterops = new TwitterOperations();
            var gui = new MainWindow();
            var ironmq = new IronMQOperations("AppZwitschern", TokenRepository.LoadFrom("ironmq.credentials.txt"));
            var serialisieren = new Serialization<Versandauftrag>();
            var urlShortener = new TinyUrlOperations();
            var compressor = new TextCompressor();

            FlowRuntimeConfiguration.SynchronizationFactory = () => new SyncWithWPFDispatcher();

            var config = new FlowRuntimeConfiguration()
                .AddStreamsFrom("az.application.flows.flow", Assembly.GetExecutingAssembly())
                .AddFunc<Versandauftrag, Versandauftrag>("versandauftrag_schnueren", twitterops.Versandauftrag_um_access_token_erweitern)
                .AddFunc<Versandauftrag, string>("serialisieren", serialisieren.Serialize)
                .AddAction<string>("enqueue", ironmq.Enqueue, true)
                .AddFunc<string, string[]>("extract_urls", compressor.Extract_Urls)
                .AddFunc<Tuple<string, Tuple<string,string>[]>,string>("replace_urls", compressor.Replace_Urls)
                .AddFunc<IEnumerable<string>, Tuple<String,string>[]>("shorten_urls", urlShortener.ShortenMany)
                .AddOperation(new AutoResetJoin<string, Tuple<string,string>[]>("join"))
                .AddOperation(new Throttle("throttle", 1000))
                .AddAction<string>("display_shortened_text", gui.ShortenedText).MakeSync()
                .AddAction("versandstatus_anzeigen", () => gui.Versandstatus("Versendet!")).MakeSync();

            using (var fr = new FlowRuntime(config)) {
                fr.UnhandledException += ex => MessageBox.Show(ex.InnerException.Message);
                fr.Message += Console.WriteLine;

                gui.Versenden += fr.CreateEventProcessor<Versandauftrag>(".versenden");
                gui.ShortenText += fr.CreateEventProcessor<string>(".shortenText");

                var app = new Application { MainWindow = gui };
                app.Run(gui);
            }
        }

        private void InternalFullSerialize(Serialization.CrySerialize serialize)
        {
            //var serialize = new Serialization.CrySerialize();
            //serialize.Handle = handle;

            FullSerialize(serialize);
        }

		internal WrappedDeserializer(Serialization.DataFormat dataFormat, string streamName, TextReader input) : base(dataFormat, streamName)
		{
			if (dataFormat != Serialization.DataFormat.None)
			{
				this.textReader = input;
				this.firstLine = this.textReader.ReadLine();
				if (string.Compare(this.firstLine, Serialization.XmlCliTag, StringComparison.OrdinalIgnoreCase) == 0)
				{
					dataFormat = Serialization.DataFormat.XML;
				}
				Serialization.DataFormat dataFormat1 = this.format;
				switch (dataFormat1)
				{
					case Serialization.DataFormat.Text:
					{
						return;
					}
					case Serialization.DataFormat.XML:
					{
						this.xmlReader = XmlReader.Create(this.textReader);
						this.xmlDeserializer = new Deserializer(this.xmlReader);
						return;
					}
					default:
					{
						return;
					}
				}
			}
			else
			{
				return;
			}
		}

 protected override void AddSerialization(Serialization.SerializationMembersList list, string name)
 {
     if (list != null)
     {
         if (HasDefaultValue)
         {
             list.Add("Serialization.SimplePropertyWithDefaultSerialization",
                 disableExport ? Templates.Serialization.SerializerType.Binary : Serialization.SerializerType.All,
                 _prop.Module.Namespace,
                 name,
                 type,
                 backingName,
                 IsSetFlagName);
         }
         else
         {
             list.Add("Serialization.SimplePropertySerialization",
                 disableExport ? Serialization.SerializerType.Binary : Serialization.SerializerType.All,
                 _prop.Module.Namespace,
                 name,
                 type,
                 backingName);
         }
     }
 }

        public override string Read(Serialization.ISerializer serializer)
        {
            if (serializer.GetType() == typeof(Arch.CFramework.AppInternals.Serialization.XMLSerializer))
            {
                XmlDocument xml = new XmlDocument();
                xml.AppendChild(xml.CreateXmlDeclaration("1.0", Encoding.UTF8.BodyName, null));
                var node = xml.CreateElement("HealthCheck");
                xml.AppendChild(node);
                var node1 = xml.CreateElement("Healthies");
                node.AppendChild(node1);
                foreach (var hcb in list.ToList())
                {
                    var n = xml.CreateElement(hcb.GetType().Name);
                    node1.AppendChild(n);
                    var n1 = xml.CreateElement("IsHealthy");
                    n1.InnerText = hcb.Healthy.IsHealthy.ToString();
                    n.AppendChild(n1);
                    n1 = xml.CreateElement("Message");
                    n1.InnerText = hcb.Healthy.Message;
                    n.AppendChild(n1);
                    n1 = xml.CreateElement("Error");
                    if (hcb.Healthy.Error != null)
                        n1.InnerText = hcb.Healthy.Error.ToString();
                    else
                        n1.InnerText = string.Empty;
                    n.AppendChild(n1);
                }

                return xml.OuterXml;
            }
            return base.Read(serializer);
        }

 protected override void OnSetState(Serialization.Mobile.SerializationInfo info, Core.StateMode mode)
 {
   base.OnSetState(info, mode);
   Name = info.GetValue<string>("SilverlightPrincipal.Criteria.Name");
   Password = info.GetValue<string>("SilverlightPrincipal.Criteria.Password");
   ProviderType = info.GetValue<string>("SilverlightPrincipal.Criteria.ProviderType");
 }

 protected override void OnGetState(Serialization.Mobile.SerializationInfo info, Core.StateMode mode)
 {
   info.AddValue("SilverlightPrincipal.Criteria.Name", Name);
   info.AddValue("SilverlightPrincipal.Criteria.Password", Password);
   info.AddValue("SilverlightPrincipal.Criteria.ProviderType", ProviderType);
   base.OnGetState(info, mode);
 }

 protected virtual void AddSerialization(Serialization.SerializationMembersList list, string underlyingCollectionName)
 {
     if (list != null)
     {
         Serialization.CollectionSerialization.Add(list, ctx, moduleNamespace, name, underlyingCollectionName, orderByValue, disableExport);
     }
 }

        public static void Call(Arebis.CodeGeneration.IGenerationHost host,
            IZetboxContext ctx, Serialization.SerializationMembersList serializationList, Property prop)
        {
            if (host == null) { throw new ArgumentNullException("host"); }

            host.CallTemplate("Properties.NotifyingDataProperty",
                ctx, serializationList, prop);
        }

 public static AHPIndexHierarchy ReadIndexHierarchyXml()
 {
     AHPIndexHierarchy TunnelHealIndex = new AHPIndexHierarchy();
     Serialization<AHPIndexHierarchy> Xml2AHPIndex = new Serialization<AHPIndexHierarchy>();
     TunnelHealIndex = Xml2AHPIndex.XMLDeserialization(_hierarchyFilePath);
     SetAhpParent(TunnelHealIndex);
     return TunnelHealIndex;
 }

 private void PersistenceManager_CurrentTreeChanged(Serialization.PersistenceManager manager, Serialization.PersistentTree oldTree, Serialization.PersistentTree newTree)
 {
     if (newTree != null)
     {
         Tab tab = mainForm.EditorTabs.FindTab(newTree);
         mainForm.EditorTabs.SelectedTab = tab;
     }
 }

        public static void Call(Arebis.CodeGeneration.IGenerationHost host,
          IZetboxContext ctx, Serialization.SerializationMembersList serializationList, string backingName)
        {
            if (host == null) { throw new ArgumentNullException("host"); }

            host.CallTemplate("Properties.ExportGuidProperty",
                ctx, serializationList, backingName);
        }

 public void SerializeInfo()
 {
     using (var conn = new NpgsqlConnection("Server=127.0.0.1;Port=5432;Database=sakila;User Id=test;Password=test;"))
     {
         conn.Open();
         var s = new Serialization();
         s.Serialize(conn);
     }
 }

 public ObjectListProperty(Arebis.CodeGeneration.IGenerationHost host,
     IZetboxContext ctx,
     Serialization.SerializationMembersList serializationList,
     Relation rel,
     RelationEndRole endRole)
     : this(host, ctx, serializationList, "name", "wrapperName", "wrapperClass", "exposedListType",
         rel, endRole, "positionPropertyName", "otherName", "referencedInterface")
 {
 }