Пример #1
0
 public WSConnectionInfo(ConnectionInfo underlying, bool incoming, string adapterName, string connectionId, global::System.Collections.Generic.Dictionary <string, string> headers) : base(underlying, incoming, adapterName, connectionId)
 {
     this.headers = headers;
     ice_initialize();
 }
Пример #2
0
		public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementLinkType == null) throw new global::System.ArgumentNullException("elementLinkType");
			if (roleAssignments == null) throw new global::System.ArgumentNullException("roleAssignments");
	
			if (createElementLinkMap == null)
			{
				createElementLinkMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(4);
				createElementLinkMap.Add(typeof(SampleOrmModelHasElements), 0);
				createElementLinkMap.Add(typeof(EntityHasRelationShips), 1);
				createElementLinkMap.Add(typeof(EntityHasProperties), 2);
				createElementLinkMap.Add(typeof(EntityHasReferences), 3);
			}
			int index;
			if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
			{
				// construct exception error message
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::Company.OrmLanguage.OrmLanguageDomainModel.SingletonResourceManager.GetString("UnrecognizedElementLinkType"),
								elementLinkType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementLinkType");
			
			}
			switch (index)
			{
				case 0: return new SampleOrmModelHasElements(partition, roleAssignments, propertyAssignments);
				case 1: return new EntityHasRelationShips(partition, roleAssignments, propertyAssignments);
				case 2: return new EntityHasProperties(partition, roleAssignments, propertyAssignments);
				case 3: return new EntityHasReferences(partition, roleAssignments, propertyAssignments);
				default: return null;
			}
		}
		/// <summary>
		/// Called to initialize the HelpKeywords dictionary.  Derived classes may override this to add custom keywords to the collection.
		/// </summary>
		protected virtual void Initialize()
		{
			this.helpKeywords = new global::System.Collections.Generic.Dictionary<string, string>(0);
		}
		public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementLinkType == null) throw new global::System.ArgumentNullException("elementLinkType");
			if (roleAssignments == null) throw new global::System.ArgumentNullException("roleAssignments");
			
			if (createElementLinkMap == null)
			{
				createElementLinkMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(0);
				createElementLinkMap.Add(typeof(VModellHasVModellvariante), 0);
				createElementLinkMap.Add(typeof(VModellvarianteHasVModellStruktur), 1);
				createElementLinkMap.Add(typeof(VModellvarianteHasTextbausteine), 2);
				createElementLinkMap.Add(typeof(VModellvarianteHasVorgehensbausteine), 3);
				createElementLinkMap.Add(typeof(VModellvarianteHasRollen), 4);
				createElementLinkMap.Add(typeof(VModellvarianteHasPDSSpezifikationen), 5);
				createElementLinkMap.Add(typeof(VModellvarianteHasAblaufbausteine), 6);
				createElementLinkMap.Add(typeof(VModellvarianteHasAblaufbausteinspezifikationen), 7);
				createElementLinkMap.Add(typeof(VModellvarianteHasProjekttypen), 8);
				createElementLinkMap.Add(typeof(VModellvarianteHasProjekttypvarianten), 9);
				createElementLinkMap.Add(typeof(VModellvarianteHasVortailoring), 10);
				createElementLinkMap.Add(typeof(VModellvarianteHasEntscheidungspunkte), 11);
				createElementLinkMap.Add(typeof(VModellvarianteHasProjektmerkmale), 12);
				createElementLinkMap.Add(typeof(VModellvarianteHasKonventionsabbildungen), 13);
				createElementLinkMap.Add(typeof(VModellvarianteHasMethodenreferenzen), 14);
				createElementLinkMap.Add(typeof(VModellvarianteHasWerkzeugreferenzen), 15);
				createElementLinkMap.Add(typeof(VModellvarianteHasGlossar), 16);
				createElementLinkMap.Add(typeof(VModellvarianteHasAbkuerzungen), 17);
				createElementLinkMap.Add(typeof(VModellvarianteHasQuellen), 18);
				createElementLinkMap.Add(typeof(VModellvarianteHasAenderungsoperationen), 19);
				createElementLinkMap.Add(typeof(VModellvarianteHasReferenzmodell), 20);
				createElementLinkMap.Add(typeof(ReferenzmodellHasVModell), 21);
				createElementLinkMap.Add(typeof(ReferenzmodellReferencesVModellvariante), 22);
				createElementLinkMap.Add(typeof(MusterbibliothekHasMustergruppe), 23);
				createElementLinkMap.Add(typeof(MustergruppeHasThemenmuster), 24);
				createElementLinkMap.Add(typeof(ThemenmusterReferencesThema), 25);
				createElementLinkMap.Add(typeof(ThemenmusterReferencesUnterthema), 26);
				createElementLinkMap.Add(typeof(ThemenmusterHasMustertext), 27);
				createElementLinkMap.Add(typeof(ThemenmusterSourceHasThemenmusterTarget), 28);
				createElementLinkMap.Add(typeof(ThemenmusterHasZusatzthema), 29);
				createElementLinkMap.Add(typeof(ZusatzthemaHasMustertext), 30);
				createElementLinkMap.Add(typeof(ZusatzthemaSourceHasZusatzthemaTarget), 31);
				createElementLinkMap.Add(typeof(MusterbibliothekHasVModell), 32);
				createElementLinkMap.Add(typeof(VariantenHasVariante), 33);
				createElementLinkMap.Add(typeof(VarianteSourceReferencesVarianteTarget), 34);
			}
			int index;
			if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
			{
				// construct exception error message
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::Tum.VModellXT.VModellXTDomainModel.SingletonResourceManager.GetString("UnrecognizedElementLinkType"),
								elementLinkType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementLinkType");
		
			}
			switch (index)
			{
				case 0: return new VModellHasVModellvariante(partition, roleAssignments, propertyAssignments);
				case 1: return new VModellvarianteHasVModellStruktur(partition, roleAssignments, propertyAssignments);
				case 2: return new VModellvarianteHasTextbausteine(partition, roleAssignments, propertyAssignments);
				case 3: return new VModellvarianteHasVorgehensbausteine(partition, roleAssignments, propertyAssignments);
				case 4: return new VModellvarianteHasRollen(partition, roleAssignments, propertyAssignments);
				case 5: return new VModellvarianteHasPDSSpezifikationen(partition, roleAssignments, propertyAssignments);
				case 6: return new VModellvarianteHasAblaufbausteine(partition, roleAssignments, propertyAssignments);
				case 7: return new VModellvarianteHasAblaufbausteinspezifikationen(partition, roleAssignments, propertyAssignments);
				case 8: return new VModellvarianteHasProjekttypen(partition, roleAssignments, propertyAssignments);
				case 9: return new VModellvarianteHasProjekttypvarianten(partition, roleAssignments, propertyAssignments);
				case 10: return new VModellvarianteHasVortailoring(partition, roleAssignments, propertyAssignments);
				case 11: return new VModellvarianteHasEntscheidungspunkte(partition, roleAssignments, propertyAssignments);
				case 12: return new VModellvarianteHasProjektmerkmale(partition, roleAssignments, propertyAssignments);
				case 13: return new VModellvarianteHasKonventionsabbildungen(partition, roleAssignments, propertyAssignments);
				case 14: return new VModellvarianteHasMethodenreferenzen(partition, roleAssignments, propertyAssignments);
				case 15: return new VModellvarianteHasWerkzeugreferenzen(partition, roleAssignments, propertyAssignments);
				case 16: return new VModellvarianteHasGlossar(partition, roleAssignments, propertyAssignments);
				case 17: return new VModellvarianteHasAbkuerzungen(partition, roleAssignments, propertyAssignments);
				case 18: return new VModellvarianteHasQuellen(partition, roleAssignments, propertyAssignments);
				case 19: return new VModellvarianteHasAenderungsoperationen(partition, roleAssignments, propertyAssignments);
				case 20: return new VModellvarianteHasReferenzmodell(partition, roleAssignments, propertyAssignments);
				case 21: return new ReferenzmodellHasVModell(partition, roleAssignments, propertyAssignments);
				case 22: return new ReferenzmodellReferencesVModellvariante(partition, roleAssignments, propertyAssignments);
				case 23: return new MusterbibliothekHasMustergruppe(partition, roleAssignments, propertyAssignments);
				case 24: return new MustergruppeHasThemenmuster(partition, roleAssignments, propertyAssignments);
				case 25: return new ThemenmusterReferencesThema(partition, roleAssignments, propertyAssignments);
				case 26: return new ThemenmusterReferencesUnterthema(partition, roleAssignments, propertyAssignments);
				case 27: return new ThemenmusterHasMustertext(partition, roleAssignments, propertyAssignments);
				case 28: return new ThemenmusterSourceHasThemenmusterTarget(partition, roleAssignments, propertyAssignments);
				case 29: return new ThemenmusterHasZusatzthema(partition, roleAssignments, propertyAssignments);
				case 30: return new ZusatzthemaHasMustertext(partition, roleAssignments, propertyAssignments);
				case 31: return new ZusatzthemaSourceHasZusatzthemaTarget(partition, roleAssignments, propertyAssignments);
				case 32: return new MusterbibliothekHasVModell(partition, roleAssignments, propertyAssignments);
				case 33: return new VariantenHasVariante(partition, roleAssignments, propertyAssignments);
				case 34: return new VarianteSourceReferencesVarianteTarget(partition, roleAssignments, propertyAssignments);
				default: return null;
			}
		}
Пример #5
0
		/// <summary>
		/// Construct the apping from XmlTagName to DomainClassInfo that derives from ModelHasClass.
		/// </summary>
		/// <param name="serializationContext">Serialization context.</param>
		/// <param name="domainDataDirectory">DomainDataDirectory to be used to discover all derived classes.</param>
		private void ConstructDerivedClassesLookupTable(DslModeling::SerializationContext serializationContext, DslModeling::DomainDataDirectory domainDataDirectory)
		{
			global::System.Diagnostics.Debug.Assert(derivedClasses == null); // Shouldn't construct the table more than once.
			derivedClasses = new global::System.Collections.Generic.Dictionary<string, DslModeling::DomainClassInfo> (global::System.StringComparer.CurrentCulture);
	
			DslModeling::DomainClassInfo thisClass = domainDataDirectory.GetDomainClass(ModelHasClass.DomainClassId);
			global::System.Diagnostics.Debug.Assert(thisClass != null, "Cannot find DomainClassInfo for ModelRoot!");
	
			global::System.Collections.ObjectModel.ReadOnlyCollection<DslModeling::DomainClassInfo> descendents = thisClass.AllDescendants;
			if (descendents != null)
			{
				foreach (DslModeling::DomainClassInfo descendent in descendents)
				{
					global::System.Type descendentType = descendent.ImplementationClass;
					if (!descendentType.IsAbstract)
					{
						DslModeling::DomainClassXmlSerializer descendentSerializer = serializationContext.Directory.GetSerializer(descendent.Id);
						if (descendentSerializer != null)
						{
							string descendentXmlTagName = descendentSerializer.XmlTagName;
							if (!string.IsNullOrEmpty (descendentXmlTagName))
							{
								global::System.Diagnostics.Debug.Assert(!derivedClasses.ContainsKey (descendentXmlTagName));
								derivedClasses.Add (descendentXmlTagName, descendent);
							}
						}
					}
					else
					{   // Ignore abstract derived classes because they cannot be instantiated directly.
					}
				}
			}
		}
Пример #6
0
		public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementType == null) throw new global::System.ArgumentNullException("elementType");
	
			if (createElementMap == null)
			{
				createElementMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(3);
				createElementMap.Add(typeof(BarkerERDiagram), 0);
				createElementMap.Add(typeof(AssociationConnector), 1);
				createElementMap.Add(typeof(BarkerEntityShape), 2);
			}
			int index;
			if (!createElementMap.TryGetValue(elementType, out index))
			{
				throw new global::System.ArgumentException("elementType is not recognized as a type of domain class which belongs to this domain model.");
			}
			switch (index)
			{
				// A constructor was not generated for BarkerERDiagram because it had HasCustomConstructor
				// set to true. Please provide the constructor below.
				case 0: return new BarkerERDiagram(partition, propertyAssignments);
				case 1: return new AssociationConnector(partition, propertyAssignments);
				case 2: return new BarkerEntityShape(partition, propertyAssignments);
				default: return null;
			}
		}
 /// <summary>
 /// Gets an EntityQuery instance that can be used to load <see cref="User2"/> entity instances using the 'Login' query.
 /// </summary>
 /// <param name="userName">The value for the 'userName' parameter of the query.</param>
 /// <param name="password">The value for the 'password' parameter of the query.</param>
 /// <param name="isPersistent">The value for the 'isPersistent' parameter of the query.</param>
 /// <param name="customData">The value for the 'customData' parameter of the query.</param>
 /// <returns>An EntityQuery that can be loaded to retrieve <see cref="User2"/> entity instances.</returns>
 public global::OpenRiaServices.DomainServices.Client.EntityQuery<global::RootNamespace.TestNamespace.User2> LoginQuery(string userName, string password, bool isPersistent, string customData)
 {
     global::System.Collections.Generic.Dictionary<string, object> parameters = new global::System.Collections.Generic.Dictionary<string, object>();
     parameters.Add("userName", userName);
     parameters.Add("password", password);
     parameters.Add("isPersistent", isPersistent);
     parameters.Add("customData", customData);
     this.ValidateMethod("LoginQuery", parameters);
     return base.CreateQuery<global::RootNamespace.TestNamespace.User2>("Login", parameters, true, false);
 }
Пример #8
0
        public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
        {
            if (elementLinkType == null)
            {
                throw new global::System.ArgumentNullException("elementType");
            }
            if (roleAssignments == null)
            {
                throw new global::System.ArgumentNullException("roleAssignments");
            }

            if (createElementLinkMap == null)
            {
                createElementLinkMap = new global::System.Collections.Generic.Dictionary <global::System.Type, int>(14);
                createElementLinkMap.Add(typeof(AssimilationMappingCustomizesFactType), 0);
                createElementLinkMap.Add(typeof(MappingCustomizationModelHasAssimilationMapping), 1);
                createElementLinkMap.Add(typeof(ReferenceModeNamingCustomizesObjectType), 2);
                createElementLinkMap.Add(typeof(MappingCustomizationModelHasReferenceModeNaming), 3);
                createElementLinkMap.Add(typeof(DefaultReferenceModeNamingCustomizesORMModel), 4);
                createElementLinkMap.Add(typeof(MappingCustomizationModelHasDefaultReferenceModeNaming), 5);
                createElementLinkMap.Add(typeof(SchemaIsForAbstractionModel), 6);
                createElementLinkMap.Add(typeof(TableIsPrimarilyForConceptType), 7);
                createElementLinkMap.Add(typeof(TableIsAlsoForConceptType), 8);
                createElementLinkMap.Add(typeof(TableIsAlsoForConceptTypeHasAssimilationPath), 9);
                createElementLinkMap.Add(typeof(ColumnHasConceptTypeChild), 10);
                createElementLinkMap.Add(typeof(UniquenessConstraintIsForUniqueness), 11);
                createElementLinkMap.Add(typeof(DomainIsForInformationTypeFormat), 12);
                createElementLinkMap.Add(typeof(GenerationSettingTargetsSchema), 13);
            }
            int index;

            if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
            {
                throw new global::System.ArgumentException("elementLinkType is not recognized as a type of domain relationship which belongs to this domain model.");
            }
            switch (index)
            {
            case 0: return(new AssimilationMappingCustomizesFactType(partition, roleAssignments, propertyAssignments));

            case 1: return(new MappingCustomizationModelHasAssimilationMapping(partition, roleAssignments, propertyAssignments));

            case 2: return(new ReferenceModeNamingCustomizesObjectType(partition, roleAssignments, propertyAssignments));

            case 3: return(new MappingCustomizationModelHasReferenceModeNaming(partition, roleAssignments, propertyAssignments));

            case 4: return(new DefaultReferenceModeNamingCustomizesORMModel(partition, roleAssignments, propertyAssignments));

            case 5: return(new MappingCustomizationModelHasDefaultReferenceModeNaming(partition, roleAssignments, propertyAssignments));

            case 6: return(new SchemaIsForAbstractionModel(partition, roleAssignments, propertyAssignments));

            case 7: return(new TableIsPrimarilyForConceptType(partition, roleAssignments, propertyAssignments));

            case 8: return(new TableIsAlsoForConceptType(partition, roleAssignments, propertyAssignments));

            case 9: return(new TableIsAlsoForConceptTypeHasAssimilationPath(partition, roleAssignments, propertyAssignments));

            case 10: return(new ColumnHasConceptTypeChild(partition, roleAssignments, propertyAssignments));

            case 11: return(new UniquenessConstraintIsForUniqueness(partition, roleAssignments, propertyAssignments));

            case 12: return(new DomainIsForInformationTypeFormat(partition, roleAssignments, propertyAssignments));

            case 13: return(new GenerationSettingTargetsSchema(partition, roleAssignments, propertyAssignments));

            default: return(null);
            }
        }
Пример #9
0
 public MapMsg()
 {
     navigation_path = new global::System.Collections.Generic.Dictionary <string, NavigationPath>();
     OnConstructor();
 }
Пример #10
0
        public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
        {
            if (elementType == null)
            {
                throw new global::System.ArgumentNullException("elementType");
            }

            if (createElementMap == null)
            {
                createElementMap = new global::System.Collections.Generic.Dictionary <global::System.Type, int>(25);
                createElementMap.Add(typeof(ModeloClassWEB), 0);
                createElementMap.Add(typeof(Clase), 1);
                createElementMap.Add(typeof(Atributo), 2);
                createElementMap.Add(typeof(Operaciones), 3);
                createElementMap.Add(typeof(ClaseEnriquecida), 4);
                createElementMap.Add(typeof(EstilosClase), 5);
                createElementMap.Add(typeof(EstiloAtributos), 6);
                createElementMap.Add(typeof(EstiloMetodos), 7);
                createElementMap.Add(typeof(Herencia), 8);
                createElementMap.Add(typeof(AtributoIdentificador), 9);
                createElementMap.Add(typeof(Parametros), 10);
                createElementMap.Add(typeof(UMLSPFDiagram), 11);
                createElementMap.Add(typeof(ConecClase), 12);
                createElementMap.Add(typeof(ConEsPadre), 13);
                createElementMap.Add(typeof(ConEsHijo), 14);
                createElementMap.Add(typeof(ShapeOperaciones), 15);
                createElementMap.Add(typeof(ShapeClase), 16);
                createElementMap.Add(typeof(ShapeParametro), 17);
                createElementMap.Add(typeof(ShapeAtributoID), 18);
                createElementMap.Add(typeof(ShapeAtributo), 19);
                createElementMap.Add(typeof(ShapeClaseEnriquecida), 20);
                createElementMap.Add(typeof(ShapeEstiloClase), 21);
                createElementMap.Add(typeof(ShapeEstiloMetodos), 22);
                createElementMap.Add(typeof(ShapeAtributos), 23);
                createElementMap.Add(typeof(IMGHerencia), 24);
            }
            int index;

            if (!createElementMap.TryGetValue(elementType, out index))
            {
                // construct exception error message
                string exceptionError = string.Format(
                    global::System.Globalization.CultureInfo.CurrentCulture,
                    global::IPS.UMLSPF.UMLSPFDomainModel.SingletonResourceManager.GetString("UnrecognizedElementType"),
                    elementType.Name);
                throw new global::System.ArgumentException(exceptionError, "elementType");
            }
            switch (index)
            {
            case 0: return(new ModeloClassWEB(partition, propertyAssignments));

            case 1: return(new Clase(partition, propertyAssignments));

            case 2: return(new Atributo(partition, propertyAssignments));

            case 3: return(new Operaciones(partition, propertyAssignments));

            case 4: return(new ClaseEnriquecida(partition, propertyAssignments));

            case 5: return(new EstilosClase(partition, propertyAssignments));

            case 6: return(new EstiloAtributos(partition, propertyAssignments));

            case 7: return(new EstiloMetodos(partition, propertyAssignments));

            case 8: return(new Herencia(partition, propertyAssignments));

            case 9: return(new AtributoIdentificador(partition, propertyAssignments));

            case 10: return(new Parametros(partition, propertyAssignments));

            case 11: return(new UMLSPFDiagram(partition, propertyAssignments));

            case 12: return(new ConecClase(partition, propertyAssignments));

            case 13: return(new ConEsPadre(partition, propertyAssignments));

            case 14: return(new ConEsHijo(partition, propertyAssignments));

            case 15: return(new ShapeOperaciones(partition, propertyAssignments));

            case 16: return(new ShapeClase(partition, propertyAssignments));

            case 17: return(new ShapeParametro(partition, propertyAssignments));

            case 18: return(new ShapeAtributoID(partition, propertyAssignments));

            case 19: return(new ShapeAtributo(partition, propertyAssignments));

            case 20: return(new ShapeClaseEnriquecida(partition, propertyAssignments));

            case 21: return(new ShapeEstiloClase(partition, propertyAssignments));

            case 22: return(new ShapeEstiloMetodos(partition, propertyAssignments));

            case 23: return(new ShapeAtributos(partition, propertyAssignments));

            case 24: return(new IMGHerencia(partition, propertyAssignments));

            default: return(null);
            }
        }
Пример #11
0
        public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
        {
            if (elementLinkType == null)
            {
                throw new global::System.ArgumentNullException("elementLinkType");
            }
            if (roleAssignments == null)
            {
                throw new global::System.ArgumentNullException("roleAssignments");
            }

            if (createElementLinkMap == null)
            {
                createElementLinkMap = new global::System.Collections.Generic.Dictionary <global::System.Type, int>(12);
                createElementLinkMap.Add(typeof(ModeloClassWEBHasClass), 0);
                createElementLinkMap.Add(typeof(ClaseHasAtrib), 1);
                createElementLinkMap.Add(typeof(ClaseHasMethods), 2);
                createElementLinkMap.Add(typeof(conAsociacion), 3);
                createElementLinkMap.Add(typeof(ClaseEnriquecidaHasClassStyle), 4);
                createElementLinkMap.Add(typeof(ClaseEnriquecidaHasAtribStyle), 5);
                createElementLinkMap.Add(typeof(ClaseEnriquecidaHasMethodsStyle), 6);
                createElementLinkMap.Add(typeof(ModeloClassWEBHasHerencia), 7);
                createElementLinkMap.Add(typeof(EsPadre), 8);
                createElementLinkMap.Add(typeof(EsHija), 9);
                createElementLinkMap.Add(typeof(ClaseHasAtribID), 10);
                createElementLinkMap.Add(typeof(OperacionesHasParams), 11);
            }
            int index;

            if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
            {
                // construct exception error message
                string exceptionError = string.Format(
                    global::System.Globalization.CultureInfo.CurrentCulture,
                    global::IPS.UMLSPF.UMLSPFDomainModel.SingletonResourceManager.GetString("UnrecognizedElementLinkType"),
                    elementLinkType.Name);
                throw new global::System.ArgumentException(exceptionError, "elementLinkType");
            }
            switch (index)
            {
            case 0: return(new ModeloClassWEBHasClass(partition, roleAssignments, propertyAssignments));

            case 1: return(new ClaseHasAtrib(partition, roleAssignments, propertyAssignments));

            case 2: return(new ClaseHasMethods(partition, roleAssignments, propertyAssignments));

            case 3: return(new conAsociacion(partition, roleAssignments, propertyAssignments));

            case 4: return(new ClaseEnriquecidaHasClassStyle(partition, roleAssignments, propertyAssignments));

            case 5: return(new ClaseEnriquecidaHasAtribStyle(partition, roleAssignments, propertyAssignments));

            case 6: return(new ClaseEnriquecidaHasMethodsStyle(partition, roleAssignments, propertyAssignments));

            case 7: return(new ModeloClassWEBHasHerencia(partition, roleAssignments, propertyAssignments));

            case 8: return(new EsPadre(partition, roleAssignments, propertyAssignments));

            case 9: return(new EsHija(partition, roleAssignments, propertyAssignments));

            case 10: return(new ClaseHasAtribID(partition, roleAssignments, propertyAssignments));

            case 11: return(new OperacionesHasParams(partition, roleAssignments, propertyAssignments));

            default: return(null);
            }
        }
Пример #12
0
 public LanguagesContainer(int[] indexes, global::System.Collections.Generic.Dictionary <string, LanguageEntry> languages)
 {
     this.Indexes   = indexes;
     this.Languages = languages;
 }
Пример #13
0
        public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
        {
            if (elementLinkType == null)
            {
                throw new global::System.ArgumentNullException("elementLinkType");
            }
            if (roleAssignments == null)
            {
                throw new global::System.ArgumentNullException("roleAssignments");
            }

            if (createElementLinkMap == null)
            {
                createElementLinkMap = new global::System.Collections.Generic.Dictionary <global::System.Type, int>(18);
                createElementLinkMap.Add(typeof(ComponentModelHasComments), 0);
                createElementLinkMap.Add(typeof(ComponentModelHasControllers), 1);
                createElementLinkMap.Add(typeof(CommentReferencesSubjects), 2);
                createElementLinkMap.Add(typeof(ControllerHasStates), 3);
                createElementLinkMap.Add(typeof(StateHasShowForms), 4);
                createElementLinkMap.Add(typeof(ShowFormHasEvents), 5);
                createElementLinkMap.Add(typeof(ShowFormHasPrimitives), 6);
                createElementLinkMap.Add(typeof(C), 7);
                createElementLinkMap.Add(typeof(ClassWithPortsHasIP), 8);
                createElementLinkMap.Add(typeof(ClassWithPortsHasOP), 9);
                createElementLinkMap.Add(typeof(StateReferencesTargetStated), 10);
                createElementLinkMap.Add(typeof(StateReferencesPs), 11);
                createElementLinkMap.Add(typeof(StateHasConditionalBlocks), 12);
                createElementLinkMap.Add(typeof(StateHasServiceCalls), 13);
                createElementLinkMap.Add(typeof(StateHasAppCodes), 14);
                createElementLinkMap.Add(typeof(AppCodeHasStringCodes), 15);
                createElementLinkMap.Add(typeof(StateHasUIDataLinks), 16);
                createElementLinkMap.Add(typeof(UIDLinkHasStringCodes), 17);
            }
            int index;

            if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
            {
                // construct exception error message
                string exceptionError = string.Format(
                    global::System.Globalization.CultureInfo.CurrentCulture,
                    global::Company.MobileDSL.MobileDSLDomainModel.SingletonResourceManager.GetString("UnrecognizedElementLinkType"),
                    elementLinkType.Name);
                throw new global::System.ArgumentException(exceptionError, "elementLinkType");
            }
            switch (index)
            {
            case 0: return(new ComponentModelHasComments(partition, roleAssignments, propertyAssignments));

            case 1: return(new ComponentModelHasControllers(partition, roleAssignments, propertyAssignments));

            case 2: return(new CommentReferencesSubjects(partition, roleAssignments, propertyAssignments));

            case 3: return(new ControllerHasStates(partition, roleAssignments, propertyAssignments));

            case 4: return(new StateHasShowForms(partition, roleAssignments, propertyAssignments));

            case 5: return(new ShowFormHasEvents(partition, roleAssignments, propertyAssignments));

            case 6: return(new ShowFormHasPrimitives(partition, roleAssignments, propertyAssignments));

            case 7: return(new C(partition, roleAssignments, propertyAssignments));

            case 8: return(new ClassWithPortsHasIP(partition, roleAssignments, propertyAssignments));

            case 9: return(new ClassWithPortsHasOP(partition, roleAssignments, propertyAssignments));

            case 10: return(new StateReferencesTargetStated(partition, roleAssignments, propertyAssignments));

            case 11: return(new StateReferencesPs(partition, roleAssignments, propertyAssignments));

            case 12: return(new StateHasConditionalBlocks(partition, roleAssignments, propertyAssignments));

            case 13: return(new StateHasServiceCalls(partition, roleAssignments, propertyAssignments));

            case 14: return(new StateHasAppCodes(partition, roleAssignments, propertyAssignments));

            case 15: return(new AppCodeHasStringCodes(partition, roleAssignments, propertyAssignments));

            case 16: return(new StateHasUIDataLinks(partition, roleAssignments, propertyAssignments));

            case 17: return(new UIDLinkHasStringCodes(partition, roleAssignments, propertyAssignments));

            default: return(null);
            }
        }
Пример #14
0
        public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
        {
            if (elementType == null)
            {
                throw new global::System.ArgumentNullException("elementType");
            }

            if (createElementMap == null)
            {
                createElementMap = new global::System.Collections.Generic.Dictionary <global::System.Type, int>(42);
                createElementMap.Add(typeof(ComponentModel), 0);
                createElementMap.Add(typeof(Controller), 1);
                createElementMap.Add(typeof(Comment), 2);
                createElementMap.Add(typeof(State), 3);
                createElementMap.Add(typeof(ShowForm), 4);
                createElementMap.Add(typeof(Event), 5);
                createElementMap.Add(typeof(Primitive), 6);
                createElementMap.Add(typeof(Button), 7);
                createElementMap.Add(typeof(IP), 8);
                createElementMap.Add(typeof(OP), 9);
                createElementMap.Add(typeof(DLink), 10);
                createElementMap.Add(typeof(Label), 11);
                createElementMap.Add(typeof(DropBox), 12);
                createElementMap.Add(typeof(ListBox), 13);
                createElementMap.Add(typeof(StackPanel), 14);
                createElementMap.Add(typeof(Input), 15);
                createElementMap.Add(typeof(ConditionalBlock), 16);
                createElementMap.Add(typeof(ServiceCall), 17);
                createElementMap.Add(typeof(AppCode), 18);
                createElementMap.Add(typeof(StringCode), 19);
                createElementMap.Add(typeof(UIDLink), 20);
                createElementMap.Add(typeof(MobileDSLDiagram), 21);
                createElementMap.Add(typeof(AssociationLink), 22);
                createElementMap.Add(typeof(CommentLink), 23);
                createElementMap.Add(typeof(StateConnector), 24);
                createElementMap.Add(typeof(ShowFormToPortConnection), 25);
                createElementMap.Add(typeof(CConnector), 26);
                createElementMap.Add(typeof(StateRefState), 27);
                createElementMap.Add(typeof(ControllerShape), 28);
                createElementMap.Add(typeof(CommentBoxShape), 29);
                createElementMap.Add(typeof(StateShape), 30);
                createElementMap.Add(typeof(ShowFormShape), 31);
                createElementMap.Add(typeof(AppCodeShape), 32);
                createElementMap.Add(typeof(UIDataLink), 33);
                createElementMap.Add(typeof(ServiceCallShape), 34);
                createElementMap.Add(typeof(ConditionalBlock2Shape), 35);
                createElementMap.Add(typeof(IPShape), 36);
                createElementMap.Add(typeof(OPShape), 37);
            }
            int index;

            if (!createElementMap.TryGetValue(elementType, out index))
            {
                // construct exception error message
                string exceptionError = string.Format(
                    global::System.Globalization.CultureInfo.CurrentCulture,
                    global::Company.MobileDSL.MobileDSLDomainModel.SingletonResourceManager.GetString("UnrecognizedElementType"),
                    elementType.Name);
                throw new global::System.ArgumentException(exceptionError, "elementType");
            }
            switch (index)
            {
            case 0: return(new ComponentModel(partition, propertyAssignments));

            case 1: return(new Controller(partition, propertyAssignments));

            case 2: return(new Comment(partition, propertyAssignments));

            case 3: return(new State(partition, propertyAssignments));

            case 4: return(new ShowForm(partition, propertyAssignments));

            case 5: return(new Event(partition, propertyAssignments));

            case 6: return(new Primitive(partition, propertyAssignments));

            case 7: return(new Button(partition, propertyAssignments));

            case 8: return(new IP(partition, propertyAssignments));

            case 9: return(new OP(partition, propertyAssignments));

            case 10: return(new DLink(partition, propertyAssignments));

            case 11: return(new Label(partition, propertyAssignments));

            case 12: return(new DropBox(partition, propertyAssignments));

            case 13: return(new ListBox(partition, propertyAssignments));

            case 14: return(new StackPanel(partition, propertyAssignments));

            case 15: return(new Input(partition, propertyAssignments));

            case 16: return(new ConditionalBlock(partition, propertyAssignments));

            case 17: return(new ServiceCall(partition, propertyAssignments));

            case 18: return(new AppCode(partition, propertyAssignments));

            case 19: return(new StringCode(partition, propertyAssignments));

            case 20: return(new UIDLink(partition, propertyAssignments));

            case 21: return(new MobileDSLDiagram(partition, propertyAssignments));

            case 22: return(new AssociationLink(partition, propertyAssignments));

            case 23: return(new CommentLink(partition, propertyAssignments));

            case 24: return(new StateConnector(partition, propertyAssignments));

            case 25: return(new ShowFormToPortConnection(partition, propertyAssignments));

            case 26: return(new CConnector(partition, propertyAssignments));

            case 27: return(new StateRefState(partition, propertyAssignments));

            case 28: return(new ControllerShape(partition, propertyAssignments));

            case 29: return(new CommentBoxShape(partition, propertyAssignments));

            case 30: return(new StateShape(partition, propertyAssignments));

            case 31: return(new ShowFormShape(partition, propertyAssignments));

            case 32: return(new AppCodeShape(partition, propertyAssignments));

            case 33: return(new UIDataLink(partition, propertyAssignments));

            case 34: return(new ServiceCallShape(partition, propertyAssignments));

            case 35: return(new ConditionalBlock2Shape(partition, propertyAssignments));

            case 36: return(new IPShape(partition, propertyAssignments));

            case 37: return(new OPShape(partition, propertyAssignments));

            default: return(null);
            }
        }
Пример #15
0
		public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementLinkType == null) throw new global::System.ArgumentNullException("elementLinkType");
			if (roleAssignments == null) throw new global::System.ArgumentNullException("roleAssignments");
	
			if (createElementLinkMap == null)
			{
				createElementLinkMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(10);
				createElementLinkMap.Add(typeof(ServiceContractModelHasServiceContracts), 0);
				createElementLinkMap.Add(typeof(ServiceContractModelHasOperations), 1);
				createElementLinkMap.Add(typeof(ServiceContractReferencesOperations), 2);
				createElementLinkMap.Add(typeof(ServiceContractModelHasServices), 3);
				createElementLinkMap.Add(typeof(ServiceReferencesServiceContract), 4);
				createElementLinkMap.Add(typeof(OperationHasFaults), 5);
				createElementLinkMap.Add(typeof(ServiceContractModelHasMessages), 6);
				createElementLinkMap.Add(typeof(RequestReferencedByOperation), 7);
				createElementLinkMap.Add(typeof(OperationReferencesResponse), 8);
				createElementLinkMap.Add(typeof(MessageHasMessageParts), 9);
			}
			int index;
			if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
			{
				// construct exception error message
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::Microsoft.Practices.ServiceFactory.ServiceContracts.ServiceContractDslDomainModel.SingletonResourceManager.GetString("UnrecognizedElementLinkType"),
								elementLinkType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementLinkType");
			
			}
			switch (index)
			{
				case 0: return new ServiceContractModelHasServiceContracts(partition, roleAssignments, propertyAssignments);
				case 1: return new ServiceContractModelHasOperations(partition, roleAssignments, propertyAssignments);
				case 2: return new ServiceContractReferencesOperations(partition, roleAssignments, propertyAssignments);
				case 3: return new ServiceContractModelHasServices(partition, roleAssignments, propertyAssignments);
				case 4: return new ServiceReferencesServiceContract(partition, roleAssignments, propertyAssignments);
				case 5: return new OperationHasFaults(partition, roleAssignments, propertyAssignments);
				case 6: return new ServiceContractModelHasMessages(partition, roleAssignments, propertyAssignments);
				case 7: return new RequestReferencedByOperation(partition, roleAssignments, propertyAssignments);
				case 8: return new OperationReferencesResponse(partition, roleAssignments, propertyAssignments);
				case 9: return new MessageHasMessageParts(partition, roleAssignments, propertyAssignments);
				default: return null;
			}
		}
 /// <summary>
 /// Get an entity of type global::EFCoreSecurityODataConsoleClient.ContactRecord as global::EFCoreSecurityODataConsoleClient.ContactRecordSingle specified by key from an entity set
 /// </summary>
 /// <param name="source">source entity set</param>
 /// <param name="keys">dictionary with the names and values of keys</param>
 public static global::EFCoreSecurityODataConsoleClient.ContactRecordSingle ByKey(this global::Microsoft.OData.Client.DataServiceQuery <global::EFCoreSecurityODataConsoleClient.ContactRecord> source, global::System.Collections.Generic.Dictionary <string, object> keys)
 {
     return(new global::EFCoreSecurityODataConsoleClient.ContactRecordSingle(source.Context, source.GetKeyPath(global::Microsoft.OData.Client.Serializer.GetKeyString(source.Context, keys))));
 }
Пример #17
0
		public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementLinkType == null) throw new global::System.ArgumentNullException("elementLinkType");
			if (roleAssignments == null) throw new global::System.ArgumentNullException("roleAssignments");
	
			if (createElementLinkMap == null)
			{
				createElementLinkMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(15);
				createElementLinkMap.Add(typeof(UnidirectionalAssociation), 0);
				createElementLinkMap.Add(typeof(ClassHasAttributes), 1);
				createElementLinkMap.Add(typeof(ModelRootHasComments), 2);
				createElementLinkMap.Add(typeof(ClassHasOperations), 3);
				createElementLinkMap.Add(typeof(Generalization), 4);
				createElementLinkMap.Add(typeof(BidirectionalAssociation), 5);
				createElementLinkMap.Add(typeof(InterfaceHasOperation), 6);
				createElementLinkMap.Add(typeof(MultipleAssociationRole), 7);
				createElementLinkMap.Add(typeof(AssociationClassRelationship), 8);
				createElementLinkMap.Add(typeof(Aggregation), 9);
				createElementLinkMap.Add(typeof(Composition), 10);
				createElementLinkMap.Add(typeof(ModelRootHasTypes), 11);
				createElementLinkMap.Add(typeof(CommentReferencesSubjects), 12);
				createElementLinkMap.Add(typeof(Implementation), 13);
			}
			int index;
			if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
			{
				// construct exception error message
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::LinqToRdf.Design.LinqToRdfDomainModel.SingletonResourceManager.GetString("UnrecognizedElementLinkType"),
								elementLinkType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementLinkType");
			
			}
			switch (index)
			{
				case 0: return new UnidirectionalAssociation(partition, roleAssignments, propertyAssignments);
				case 1: return new ClassHasAttributes(partition, roleAssignments, propertyAssignments);
				case 2: return new ModelRootHasComments(partition, roleAssignments, propertyAssignments);
				case 3: return new ClassHasOperations(partition, roleAssignments, propertyAssignments);
				case 4: return new Generalization(partition, roleAssignments, propertyAssignments);
				case 5: return new BidirectionalAssociation(partition, roleAssignments, propertyAssignments);
				case 6: return new InterfaceHasOperation(partition, roleAssignments, propertyAssignments);
				case 7: return new MultipleAssociationRole(partition, roleAssignments, propertyAssignments);
				case 8: return new AssociationClassRelationship(partition, roleAssignments, propertyAssignments);
				case 9: return new Aggregation(partition, roleAssignments, propertyAssignments);
				case 10: return new Composition(partition, roleAssignments, propertyAssignments);
				case 11: return new ModelRootHasTypes(partition, roleAssignments, propertyAssignments);
				case 12: return new CommentReferencesSubjects(partition, roleAssignments, propertyAssignments);
				case 13: return new Implementation(partition, roleAssignments, propertyAssignments);
				default: return null;
			}
		}
Пример #18
0
 public Snapshot(global::Improbable.TestSchema.ExhaustiveRepeatedData a, global::Improbable.TestSchema.SomeEnum b, global::Improbable.TestSchema.SomeEnum?c, global::System.Collections.Generic.List <global::Improbable.TestSchema.SomeType> d, global::System.Collections.Generic.Dictionary <global::Improbable.TestSchema.SomeEnum, global::Improbable.TestSchema.SomeType> e)
 {
     A = a;
     B = b;
     C = c;
     D = d;
     E = e;
 }
Пример #19
0
		public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementLinkType == null) throw new global::System.ArgumentNullException("elementLinkType");
			if (roleAssignments == null) throw new global::System.ArgumentNullException("roleAssignments");
	
			if (createElementLinkMap == null)
			{
				createElementLinkMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(6);
				createElementLinkMap.Add(typeof(HostDesignerModelHasHostApplications), 0);
				createElementLinkMap.Add(typeof(HostApplicationHasServiceDescriptions), 1);
				createElementLinkMap.Add(typeof(ServiceDescriptionHasEndpoints), 2);
				createElementLinkMap.Add(typeof(ClientApplicationHasProxies), 3);
				createElementLinkMap.Add(typeof(ProxyReferencesEndpoint), 4);
				createElementLinkMap.Add(typeof(HostDesignerModelHasClientApplications), 5);
			}
			int index;
			if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
			{
				// construct exception error message
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::Microsoft.Practices.ServiceFactory.HostDesigner.HostDesignerDomainModel.SingletonResourceManager.GetString("UnrecognizedElementLinkType"),
								elementLinkType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementLinkType");
			
			}
			switch (index)
			{
				case 0: return new HostDesignerModelHasHostApplications(partition, roleAssignments, propertyAssignments);
				case 1: return new HostApplicationHasServiceDescriptions(partition, roleAssignments, propertyAssignments);
				case 2: return new ServiceDescriptionHasEndpoints(partition, roleAssignments, propertyAssignments);
				case 3: return new ClientApplicationHasProxies(partition, roleAssignments, propertyAssignments);
				case 4: return new ProxyReferencesEndpoint(partition, roleAssignments, propertyAssignments);
				case 5: return new HostDesignerModelHasClientApplications(partition, roleAssignments, propertyAssignments);
				default: return null;
			}
		}
Пример #20
0
            private global::Ice.AsyncResult <Callback_AStockService_GetCompanyInfo> begin_GetCompanyInfo(int iceP_id, global::System.Collections.Generic.Dictionary <string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
            {
                iceCheckAsyncTwowayOnly(_GetCompanyInfo_name);
                var completed = new global::IceInternal.OperationAsyncResultCompletionCallback <Callback_AStockService_GetCompanyInfo, CompanyInfo>(
                    (Callback_AStockService_GetCompanyInfo cb, CompanyInfo ret) =>
                {
                    if (cb != null)
                    {
                        cb.Invoke(ret);
                    }
                },
                    this, _GetCompanyInfo_name, cookie, completedCallback);

                _iceI_GetCompanyInfo(iceP_id, context, synchronous, completed);
                return(completed);
            }
Пример #21
0
		public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementLinkType == null) throw new global::System.ArgumentNullException("elementLinkType");
			if (roleAssignments == null) throw new global::System.ArgumentNullException("roleAssignments");
	
			if (createElementLinkMap == null)
			{
				createElementLinkMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(9);
				createElementLinkMap.Add(typeof(ModelHasClass), 0);
				createElementLinkMap.Add(typeof(ManyToOneRelation), 1);
				createElementLinkMap.Add(typeof(ClassHasProperty), 2);
				createElementLinkMap.Add(typeof(ManyToManyRelation), 3);
				createElementLinkMap.Add(typeof(OneToOneRelation), 4);
				createElementLinkMap.Add(typeof(ModelHasNestedClasses), 5);
				createElementLinkMap.Add(typeof(NestedClassHasProperties), 6);
				createElementLinkMap.Add(typeof(NestedClassReferencesModelClasses), 7);
				createElementLinkMap.Add(typeof(InheritanceRelation), 8);
			}
			int index;
			if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
			{
				// construct exception error message
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::Castle.ActiveWriter.ActiveWriterDomainModel.SingletonResourceManager.GetString("UnrecognizedElementLinkType"),
								elementLinkType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementLinkType");
			
			}
			switch (index)
			{
				case 0: return new ModelHasClass(partition, roleAssignments, propertyAssignments);
				case 1: return new ManyToOneRelation(partition, roleAssignments, propertyAssignments);
				case 2: return new ClassHasProperty(partition, roleAssignments, propertyAssignments);
				case 3: return new ManyToManyRelation(partition, roleAssignments, propertyAssignments);
				case 4: return new OneToOneRelation(partition, roleAssignments, propertyAssignments);
				case 5: return new ModelHasNestedClasses(partition, roleAssignments, propertyAssignments);
				case 6: return new NestedClassHasProperties(partition, roleAssignments, propertyAssignments);
				case 7: return new NestedClassReferencesModelClasses(partition, roleAssignments, propertyAssignments);
				case 8: return new InheritanceRelation(partition, roleAssignments, propertyAssignments);
				default: return null;
			}
		}
Пример #22
0
 public static AStockServicePrx checkedCast(global::Ice.ObjectPrx b, string f, global::System.Collections.Generic.Dictionary <string, string> ctx)
 {
     if (b == null)
     {
         return(null);
     }
     global::Ice.ObjectPrx bb = b.ice_facet(f);
     try
     {
         if (bb.ice_isA(ice_staticId(), ctx))
         {
             AStockServicePrxHelper h = new AStockServicePrxHelper();
             h.iceCopyFrom(bb);
             return(h);
         }
     }
     catch (global::Ice.FacetNotExistException)
     {
     }
     return(null);
 }
Пример #23
0
		public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementLinkType == null) throw new global::System.ArgumentNullException("elementType");
			if (roleAssignments == null) throw new global::System.ArgumentNullException("roleAssignments");
	
			if (createElementLinkMap == null)
			{
				createElementLinkMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(14);
				createElementLinkMap.Add(typeof(AssimilationMappingCustomizesFactType), 0);
				createElementLinkMap.Add(typeof(MappingCustomizationModelHasAssimilationMapping), 1);
				createElementLinkMap.Add(typeof(ReferenceModeNamingCustomizesObjectType), 2);
				createElementLinkMap.Add(typeof(MappingCustomizationModelHasReferenceModeNaming), 3);
				createElementLinkMap.Add(typeof(DefaultReferenceModeNamingCustomizesORMModel), 4);
				createElementLinkMap.Add(typeof(MappingCustomizationModelHasDefaultReferenceModeNaming), 5);
				createElementLinkMap.Add(typeof(SchemaIsForAbstractionModel), 6);
				createElementLinkMap.Add(typeof(TableIsPrimarilyForConceptType), 7);
				createElementLinkMap.Add(typeof(TableIsAlsoForConceptType), 8);
				createElementLinkMap.Add(typeof(TableIsAlsoForConceptTypeHasAssimilationPath), 9);
				createElementLinkMap.Add(typeof(ColumnHasConceptTypeChild), 10);
				createElementLinkMap.Add(typeof(UniquenessConstraintIsForUniqueness), 11);
				createElementLinkMap.Add(typeof(DomainIsForInformationTypeFormat), 12);
				createElementLinkMap.Add(typeof(GenerationSettingTargetsSchema), 13);
			}
			int index;
			if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
			{
				throw new global::System.ArgumentException("elementLinkType is not recognized as a type of domain relationship which belongs to this domain model.");
			}
			switch (index)
			{
				case 0: return new AssimilationMappingCustomizesFactType(partition, roleAssignments, propertyAssignments);
				case 1: return new MappingCustomizationModelHasAssimilationMapping(partition, roleAssignments, propertyAssignments);
				case 2: return new ReferenceModeNamingCustomizesObjectType(partition, roleAssignments, propertyAssignments);
				case 3: return new MappingCustomizationModelHasReferenceModeNaming(partition, roleAssignments, propertyAssignments);
				case 4: return new DefaultReferenceModeNamingCustomizesORMModel(partition, roleAssignments, propertyAssignments);
				case 5: return new MappingCustomizationModelHasDefaultReferenceModeNaming(partition, roleAssignments, propertyAssignments);
				case 6: return new SchemaIsForAbstractionModel(partition, roleAssignments, propertyAssignments);
				case 7: return new TableIsPrimarilyForConceptType(partition, roleAssignments, propertyAssignments);
				case 8: return new TableIsAlsoForConceptType(partition, roleAssignments, propertyAssignments);
				case 9: return new TableIsAlsoForConceptTypeHasAssimilationPath(partition, roleAssignments, propertyAssignments);
				case 10: return new ColumnHasConceptTypeChild(partition, roleAssignments, propertyAssignments);
				case 11: return new UniquenessConstraintIsForUniqueness(partition, roleAssignments, propertyAssignments);
				case 12: return new DomainIsForInformationTypeFormat(partition, roleAssignments, propertyAssignments);
				case 13: return new GenerationSettingTargetsSchema(partition, roleAssignments, propertyAssignments);
				default: return null;
			}
		}
 public ExhaustiveMapKeyData(global::System.Collections.Generic.Dictionary <bool, string> field1, global::System.Collections.Generic.Dictionary <float, string> field2, global::System.Collections.Generic.Dictionary <byte[], string> field3, global::System.Collections.Generic.Dictionary <int, string> field4, global::System.Collections.Generic.Dictionary <long, string> field5, global::System.Collections.Generic.Dictionary <double, string> field6, global::System.Collections.Generic.Dictionary <string, string> field7, global::System.Collections.Generic.Dictionary <uint, string> field8, global::System.Collections.Generic.Dictionary <ulong, string> field9, global::System.Collections.Generic.Dictionary <int, string> field10, global::System.Collections.Generic.Dictionary <long, string> field11, global::System.Collections.Generic.Dictionary <uint, string> field12, global::System.Collections.Generic.Dictionary <ulong, string> field13, global::System.Collections.Generic.Dictionary <int, string> field14, global::System.Collections.Generic.Dictionary <long, string> field15, global::System.Collections.Generic.Dictionary <global::Improbable.Gdk.Core.EntityId, string> field16, global::System.Collections.Generic.Dictionary <global::Improbable.TestSchema.SomeType, string> field17, global::System.Collections.Generic.Dictionary <global::Improbable.TestSchema.SomeEnum, string> field18)
 {
     Field1  = field1;
     Field2  = field2;
     Field3  = field3;
     Field4  = field4;
     Field5  = field5;
     Field6  = field6;
     Field7  = field7;
     Field8  = field8;
     Field9  = field9;
     Field10 = field10;
     Field11 = field11;
     Field12 = field12;
     Field13 = field13;
     Field14 = field14;
     Field15 = field15;
     Field16 = field16;
     Field17 = field17;
     Field18 = field18;
 }
Пример #25
0
		/// <summary>
		/// This method returns the moniker resolvers for each of the domain models in the store
		/// </summary>
		/// <param name="store">Store on which the moniker resolvers are set up.</param>
		internal protected virtual global::System.Collections.Generic.IDictionary<global::System.Guid, DslModeling::IMonikerResolver> GetMonikerResolvers(DslModeling::Store store)
		{
			#region Check Parameters
			global::System.Diagnostics.Debug.Assert(store != null);
			if (store == null)
				throw new global::System.ArgumentNullException("store");
			#endregion
			
			global::System.Collections.Generic.Dictionary<global::System.Guid, DslModeling::IMonikerResolver> result = new global::System.Collections.Generic.Dictionary<global::System.Guid, DslModeling::IMonikerResolver>();
			foreach (DslModeling::DomainModelInfo modelInfo in store.DomainDataDirectory.DomainModels)
			{
				if (modelInfo.MonikerResolver != null)
				{
					result.Add(modelInfo.Id, modelInfo.MonikerResolver);
				}
			}
			
			return result;
		}
Пример #26
0
 public ExhaustiveMapValueData(global::System.Collections.Generic.Dictionary <string, bool> field1, global::System.Collections.Generic.Dictionary <string, float> field2, global::System.Collections.Generic.Dictionary <string, byte[]> field3, global::System.Collections.Generic.Dictionary <string, int> field4, global::System.Collections.Generic.Dictionary <string, long> field5, global::System.Collections.Generic.Dictionary <string, double> field6, global::System.Collections.Generic.Dictionary <string, string> field7, global::System.Collections.Generic.Dictionary <string, uint> field8, global::System.Collections.Generic.Dictionary <string, ulong> field9, global::System.Collections.Generic.Dictionary <string, int> field10, global::System.Collections.Generic.Dictionary <string, long> field11, global::System.Collections.Generic.Dictionary <string, uint> field12, global::System.Collections.Generic.Dictionary <string, ulong> field13, global::System.Collections.Generic.Dictionary <string, int> field14, global::System.Collections.Generic.Dictionary <string, long> field15, global::System.Collections.Generic.Dictionary <string, global::Improbable.Gdk.Core.EntityId> field16, global::System.Collections.Generic.Dictionary <string, global::Improbable.Gdk.Tests.SomeType> field17, global::System.Collections.Generic.Dictionary <string, global::Improbable.Gdk.Tests.SomeEnum> field18)
 {
     Field1  = field1;
     Field2  = field2;
     Field3  = field3;
     Field4  = field4;
     Field5  = field5;
     Field6  = field6;
     Field7  = field7;
     Field8  = field8;
     Field9  = field9;
     Field10 = field10;
     Field11 = field11;
     Field12 = field12;
     Field13 = field13;
     Field14 = field14;
     Field15 = field15;
     Field16 = field16;
     Field17 = field17;
     Field18 = field18;
 }
Пример #27
0
		public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementLinkType == null) throw new global::System.ArgumentNullException("elementType");
			if (roleAssignments == null) throw new global::System.ArgumentNullException("roleAssignments");
	
			if (createElementLinkMap == null)
			{
				createElementLinkMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(2);
				createElementLinkMap.Add(typeof(CustomPropertyHasCustomPropertyDefinition), 0);
				createElementLinkMap.Add(typeof(CustomPropertyGroupContainsCustomPropertyDefinition), 1);
			}
			int index;
			if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
			{
				throw new global::System.ArgumentException("elementLinkType is not recognized as a type of domain relationship which belongs to this domain model.");
			}
			switch (index)
			{
				case 0: return new CustomPropertyHasCustomPropertyDefinition(partition, roleAssignments, propertyAssignments);
				case 1: return new CustomPropertyGroupContainsCustomPropertyDefinition(partition, roleAssignments, propertyAssignments);
				default: return null;
			}
		}
Пример #28
0
        private global::Ice.AsyncResult <Callback_Printer_printString> begin_printString(string iceP_s, global::System.Collections.Generic.Dictionary <string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback <Callback_Printer_printString, object>(
                (Callback_Printer_printString cb, object ret) =>
            {
                if (cb != null)
                {
                    cb.Invoke();
                }
            },
                this, _printString_name, cookie, completedCallback);

            _iceI_printString(iceP_s, context, synchronous, completed);
            return(completed);
        }
Пример #29
0
 public void AddMemberName(string shortName)
 {
     if(_memberNames == null)
     {
         _memberNames =  new global::System.Collections.Generic.Dictionary<string,string>();
     }
     _memberNames.Add(shortName, FullName + "." + shortName);
 }
Пример #30
0
        public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
        {
            if (elementType == null)
            {
                throw new global::System.ArgumentNullException("elementType");
            }

            if (createElementMap == null)
            {
                createElementMap = new global::System.Collections.Generic.Dictionary <global::System.Type, int>(22);
                createElementMap.Add(typeof(OIALModel), 0);
                createElementMap.Add(typeof(ConceptType), 1);
                createElementMap.Add(typeof(InformationTypeFormat), 2);
                createElementMap.Add(typeof(ChildSequence), 3);
                createElementMap.Add(typeof(SingleChildUniquenessConstraint), 4);
                createElementMap.Add(typeof(SingleChildFrequencyConstraint), 5);
                createElementMap.Add(typeof(ValueConstraint), 6);
                createElementMap.Add(typeof(ChildSequenceFrequencyConstraint), 7);
                createElementMap.Add(typeof(RingConstraint), 8);
                createElementMap.Add(typeof(DisjunctiveMandatoryConstraint), 9);
                createElementMap.Add(typeof(ChildSequenceUniquenessConstraint), 10);
                createElementMap.Add(typeof(MinTwoChildrenChildSequence), 11);
                createElementMap.Add(typeof(SubsetConstraint), 12);
                createElementMap.Add(typeof(ExclusionConstraint), 13);
                createElementMap.Add(typeof(EqualityConstraint), 14);
            }
            int index;

            if (!createElementMap.TryGetValue(elementType, out index))
            {
                // construct exception error message
                string exceptionError = string.Format(
                    global::System.Globalization.CultureInfo.CurrentCulture,
                    global::Neumont.Tools.ORM.OIALModel.OIALDomainModel.SingletonResourceManager.GetString("UnrecognizedElementType"),
                    elementType.Name);
                throw new global::System.ArgumentException(exceptionError, "elementType");
            }
            switch (index)
            {
            case 0: return(new OIALModel(partition, propertyAssignments));

            case 1: return(new ConceptType(partition, propertyAssignments));

            case 2: return(new InformationTypeFormat(partition, propertyAssignments));

            case 3: return(new ChildSequence(partition, propertyAssignments));

            case 4: return(new SingleChildUniquenessConstraint(partition, propertyAssignments));

            case 5: return(new SingleChildFrequencyConstraint(partition, propertyAssignments));

            case 6: return(new ValueConstraint(partition, propertyAssignments));

            case 7: return(new ChildSequenceFrequencyConstraint(partition, propertyAssignments));

            case 8: return(new RingConstraint(partition, propertyAssignments));

            case 9: return(new DisjunctiveMandatoryConstraint(partition, propertyAssignments));

            case 10: return(new ChildSequenceUniquenessConstraint(partition, propertyAssignments));

            case 11: return(new MinTwoChildrenChildSequence(partition, propertyAssignments));

            case 12: return(new SubsetConstraint(partition, propertyAssignments));

            case 13: return(new ExclusionConstraint(partition, propertyAssignments));

            case 14: return(new EqualityConstraint(partition, propertyAssignments));

            default: return(null);
            }
        }
Пример #31
0
		public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementType == null) throw new global::System.ArgumentNullException("elementType");
	
			if (createElementMap == null)
			{
				createElementMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(22);
				createElementMap.Add(typeof(ServiceContractModel), 0);
				createElementMap.Add(typeof(ServiceContract), 1);
				createElementMap.Add(typeof(Operation), 2);
				createElementMap.Add(typeof(Service), 3);
				createElementMap.Add(typeof(Message), 4);
				createElementMap.Add(typeof(DataContractMessagePart), 5);
				createElementMap.Add(typeof(PrimitiveMessagePart), 6);
				createElementMap.Add(typeof(XsdMessage), 7);
				createElementMap.Add(typeof(DataContractFault), 8);
				createElementMap.Add(typeof(XsdElementFault), 9);
				createElementMap.Add(typeof(ServiceContractDiagram), 10);
				createElementMap.Add(typeof(OperationConnector), 11);
				createElementMap.Add(typeof(ServiceConnector), 12);
				createElementMap.Add(typeof(MessageOperationConnector), 13);
				createElementMap.Add(typeof(ServiceContractShape), 14);
				createElementMap.Add(typeof(MessageShape), 15);
				createElementMap.Add(typeof(OperationShape), 16);
				createElementMap.Add(typeof(ServiceShape), 17);
				createElementMap.Add(typeof(XsdMessageShape), 18);
			}
			int index;
			if (!createElementMap.TryGetValue(elementType, out index))
			{
				// construct exception error message		
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::Microsoft.Practices.ServiceFactory.ServiceContracts.ServiceContractDslDomainModel.SingletonResourceManager.GetString("UnrecognizedElementType"),
								elementType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementType");
			}
			switch (index)
			{
				case 0: return new ServiceContractModel(partition, propertyAssignments);
				case 1: return new ServiceContract(partition, propertyAssignments);
				case 2: return new Operation(partition, propertyAssignments);
				case 3: return new Service(partition, propertyAssignments);
				case 4: return new Message(partition, propertyAssignments);
				case 5: return new DataContractMessagePart(partition, propertyAssignments);
				case 6: return new PrimitiveMessagePart(partition, propertyAssignments);
				case 7: return new XsdMessage(partition, propertyAssignments);
				case 8: return new DataContractFault(partition, propertyAssignments);
				case 9: return new XsdElementFault(partition, propertyAssignments);
				case 10: return new ServiceContractDiagram(partition, propertyAssignments);
				case 11: return new OperationConnector(partition, propertyAssignments);
				case 12: return new ServiceConnector(partition, propertyAssignments);
				case 13: return new MessageOperationConnector(partition, propertyAssignments);
				case 14: return new ServiceContractShape(partition, propertyAssignments);
				case 15: return new MessageShape(partition, propertyAssignments);
				case 16: return new OperationShape(partition, propertyAssignments);
				case 17: return new ServiceShape(partition, propertyAssignments);
				case 18: return new XsdMessageShape(partition, propertyAssignments);
				default: return null;
			}
		}
Пример #32
0
        public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
        {
            if (elementLinkType == null)
            {
                throw new global::System.ArgumentNullException("elementLinkType");
            }
            if (roleAssignments == null)
            {
                throw new global::System.ArgumentNullException("roleAssignments");
            }

            if (createElementLinkMap == null)
            {
                createElementLinkMap = new global::System.Collections.Generic.Dictionary <global::System.Type, int>(18);
                createElementLinkMap.Add(typeof(OIALModelHasORMModel), 0);
                createElementLinkMap.Add(typeof(OIALModelHasConceptType), 1);
                createElementLinkMap.Add(typeof(ConceptTypeAbsorbedConceptType), 2);
                createElementLinkMap.Add(typeof(InformationType), 3);
                createElementLinkMap.Add(typeof(OIALHasInformationTypeFormat), 4);
                createElementLinkMap.Add(typeof(ConceptTypeRef), 5);
                createElementLinkMap.Add(typeof(InformationTypeFormatHasObjectType), 6);
                createElementLinkMap.Add(typeof(ConceptTypeHasObjectType), 7);
                createElementLinkMap.Add(typeof(SingleChildSequenceConstraintHasMinTwoChildrenChildSequence), 8);
                createElementLinkMap.Add(typeof(SubsetConstraintHasSubChildSequence), 9);
                createElementLinkMap.Add(typeof(SubsetConstraintHasSuperChildSequence), 10);
                createElementLinkMap.Add(typeof(TwoOrMoreChildSequenceConstraintHasChildSequence), 11);
                createElementLinkMap.Add(typeof(ChildHasSingleChildConstraint), 12);
                createElementLinkMap.Add(typeof(OIALModelHasChildSequenceConstraint), 13);
                createElementLinkMap.Add(typeof(ConceptTypeChildHasPathRole), 14);
                createElementLinkMap.Add(typeof(ChildSequenceHasConceptTypeChild), 15);
            }
            int index;

            if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
            {
                // construct exception error message
                string exceptionError = string.Format(
                    global::System.Globalization.CultureInfo.CurrentCulture,
                    global::Neumont.Tools.ORM.OIALModel.OIALDomainModel.SingletonResourceManager.GetString("UnrecognizedElementLinkType"),
                    elementLinkType.Name);
                throw new global::System.ArgumentException(exceptionError, "elementLinkType");
            }
            switch (index)
            {
            case 0: return(new OIALModelHasORMModel(partition, roleAssignments, propertyAssignments));

            case 1: return(new OIALModelHasConceptType(partition, roleAssignments, propertyAssignments));

            case 2: return(new ConceptTypeAbsorbedConceptType(partition, roleAssignments, propertyAssignments));

            case 3: return(new InformationType(partition, roleAssignments, propertyAssignments));

            case 4: return(new OIALHasInformationTypeFormat(partition, roleAssignments, propertyAssignments));

            case 5: return(new ConceptTypeRef(partition, roleAssignments, propertyAssignments));

            case 6: return(new InformationTypeFormatHasObjectType(partition, roleAssignments, propertyAssignments));

            case 7: return(new ConceptTypeHasObjectType(partition, roleAssignments, propertyAssignments));

            case 8: return(new SingleChildSequenceConstraintHasMinTwoChildrenChildSequence(partition, roleAssignments, propertyAssignments));

            case 9: return(new SubsetConstraintHasSubChildSequence(partition, roleAssignments, propertyAssignments));

            case 10: return(new SubsetConstraintHasSuperChildSequence(partition, roleAssignments, propertyAssignments));

            case 11: return(new TwoOrMoreChildSequenceConstraintHasChildSequence(partition, roleAssignments, propertyAssignments));

            case 12: return(new ChildHasSingleChildConstraint(partition, roleAssignments, propertyAssignments));

            case 13: return(new OIALModelHasChildSequenceConstraint(partition, roleAssignments, propertyAssignments));

            case 14: return(new ConceptTypeChildHasPathRole(partition, roleAssignments, propertyAssignments));

            case 15: return(new ChildSequenceHasConceptTypeChild(partition, roleAssignments, propertyAssignments));

            default: return(null);
            }
        }
Пример #33
0
		public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementType == null) throw new global::System.ArgumentNullException("elementType");
	
			if (createElementMap == null)
			{
				createElementMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(27);
				createElementMap.Add(typeof(ModelRoot), 0);
				createElementMap.Add(typeof(ModelClass), 1);
				createElementMap.Add(typeof(ModelAttribute), 2);
				createElementMap.Add(typeof(Comment), 3);
				createElementMap.Add(typeof(ClassOperation), 4);
				createElementMap.Add(typeof(ModelInterface), 5);
				createElementMap.Add(typeof(InterfaceOperation), 6);
				createElementMap.Add(typeof(MultipleAssociation), 7);
				createElementMap.Add(typeof(ClassDiagram), 8);
				createElementMap.Add(typeof(UnidirectionalConnector), 9);
				createElementMap.Add(typeof(BidirectionalConnector), 10);
				createElementMap.Add(typeof(AggregationConnector), 11);
				createElementMap.Add(typeof(CompositionConnector), 12);
				createElementMap.Add(typeof(MultipleAssociationRoleConnector), 13);
				createElementMap.Add(typeof(AssociationClassConnector), 14);
				createElementMap.Add(typeof(GeneralizationConnector), 15);
				createElementMap.Add(typeof(ImplementationConnector), 16);
				createElementMap.Add(typeof(CommentConnector), 17);
				createElementMap.Add(typeof(CommentBoxShape), 18);
				createElementMap.Add(typeof(ClassShape), 19);
				createElementMap.Add(typeof(InterfaceShape), 20);
				createElementMap.Add(typeof(MultipleAssociationShape), 21);
			}
			int index;
			if (!createElementMap.TryGetValue(elementType, out index))
			{
				// construct exception error message		
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::LinqToRdf.Design.LinqToRdfDomainModel.SingletonResourceManager.GetString("UnrecognizedElementType"),
								elementType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementType");
			}
			switch (index)
			{
				case 0: return new ModelRoot(partition, propertyAssignments);
				case 1: return new ModelClass(partition, propertyAssignments);
				case 2: return new ModelAttribute(partition, propertyAssignments);
				case 3: return new Comment(partition, propertyAssignments);
				case 4: return new ClassOperation(partition, propertyAssignments);
				case 5: return new ModelInterface(partition, propertyAssignments);
				case 6: return new InterfaceOperation(partition, propertyAssignments);
				case 7: return new MultipleAssociation(partition, propertyAssignments);
				case 8: return new ClassDiagram(partition, propertyAssignments);
				case 9: return new UnidirectionalConnector(partition, propertyAssignments);
				case 10: return new BidirectionalConnector(partition, propertyAssignments);
				case 11: return new AggregationConnector(partition, propertyAssignments);
				case 12: return new CompositionConnector(partition, propertyAssignments);
				case 13: return new MultipleAssociationRoleConnector(partition, propertyAssignments);
				case 14: return new AssociationClassConnector(partition, propertyAssignments);
				case 15: return new GeneralizationConnector(partition, propertyAssignments);
				case 16: return new ImplementationConnector(partition, propertyAssignments);
				case 17: return new CommentConnector(partition, propertyAssignments);
				case 18: return new CommentBoxShape(partition, propertyAssignments);
				case 19: return new ClassShape(partition, propertyAssignments);
				case 20: return new InterfaceShape(partition, propertyAssignments);
				case 21: return new MultipleAssociationShape(partition, propertyAssignments);
				default: return null;
			}
		}
Пример #34
0
 public SoftwareInfo()
 {
     configs = new global::System.Collections.Generic.Dictionary <string, string>();
     OnConstructor();
 }
Пример #35
0
		public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementLinkType == null) throw new global::System.ArgumentNullException("elementLinkType");
			if (roleAssignments == null) throw new global::System.ArgumentNullException("roleAssignments");
			
			if (createElementLinkMap == null)
			{
				createElementLinkMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(0);
				createElementLinkMap.Add(typeof(DomainModelHasDomainClass2), 0);
			}
			int index;
			if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
			{
				// construct exception error message
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::Tum.PDE.VSPluginDSL.VSPluginDSLDomainModel.SingletonResourceManager.GetString("UnrecognizedElementLinkType"),
								elementLinkType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementLinkType");
		
			}
			switch (index)
			{
				case 0: return new DomainModelHasDomainClass2(partition, roleAssignments, propertyAssignments);
				default: return null;
			}
		}
Пример #36
0
 /// <summary>
 /// Called to initialize the HelpKeywords dictionary.  Derived classes may override this to add custom keywords to the collection.
 /// </summary>
 protected virtual void Initialize()
 {
     this.helpKeywords = new global::System.Collections.Generic.Dictionary <string, string>(0);
 }
Пример #37
0
		public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementType == null) throw new global::System.ArgumentNullException("elementType");
	
			if (createElementMap == null)
			{
				createElementMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(17);
				createElementMap.Add(typeof(HostDesignerModel), 0);
				createElementMap.Add(typeof(HostApplication), 1);
				createElementMap.Add(typeof(ServiceReference), 2);
				createElementMap.Add(typeof(Endpoint), 3);
				createElementMap.Add(typeof(ClientApplication), 4);
				createElementMap.Add(typeof(Proxy), 5);
				createElementMap.Add(typeof(HostDesignerDiagram), 6);
				createElementMap.Add(typeof(ServiceConnector), 7);
				createElementMap.Add(typeof(ProxyEndpointConnector), 8);
				createElementMap.Add(typeof(HostApplicationShape), 9);
				createElementMap.Add(typeof(BaseGeometryShape), 10);
				createElementMap.Add(typeof(ServiceDescriptionShape), 11);
				createElementMap.Add(typeof(ClientApplicationShape), 12);
				createElementMap.Add(typeof(EndpointPortShape), 13);
				createElementMap.Add(typeof(ProxyPortShape), 14);
			}
			int index;
			if (!createElementMap.TryGetValue(elementType, out index))
			{
				// construct exception error message		
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::Microsoft.Practices.ServiceFactory.HostDesigner.HostDesignerDomainModel.SingletonResourceManager.GetString("UnrecognizedElementType"),
								elementType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementType");
			}
			switch (index)
			{
				case 0: return new HostDesignerModel(partition, propertyAssignments);
				case 1: return new HostApplication(partition, propertyAssignments);
				case 2: return new ServiceReference(partition, propertyAssignments);
				case 3: return new Endpoint(partition, propertyAssignments);
				case 4: return new ClientApplication(partition, propertyAssignments);
				case 5: return new Proxy(partition, propertyAssignments);
				case 6: return new HostDesignerDiagram(partition, propertyAssignments);
				case 7: return new ServiceConnector(partition, propertyAssignments);
				case 8: return new ProxyEndpointConnector(partition, propertyAssignments);
				case 9: return new HostApplicationShape(partition, propertyAssignments);
				case 10: return new BaseGeometryShape(partition, propertyAssignments);
				case 11: return new ServiceDescriptionShape(partition, propertyAssignments);
				case 12: return new ClientApplicationShape(partition, propertyAssignments);
				case 13: return new EndpointPortShape(partition, propertyAssignments);
				case 14: return new ProxyPortShape(partition, propertyAssignments);
				default: return null;
			}
		}
Пример #38
0
        public virtual int UpdateAll(School_SystemDataSet3 dataSet)
        {
            if ((dataSet == null))
            {
                throw new global::System.ArgumentNullException("dataSet");
            }
            if ((dataSet.HasChanges() == false))
            {
                return(0);
            }
            global::System.Data.IDbConnection workConnection = this.Connection;
            if ((workConnection == null))
            {
                throw new global::System.ApplicationException("TableAdapterManager contains no connection information. Set each TableAdapterMana" +
                                                              "ger TableAdapter property to a valid TableAdapter instance.");
            }
            bool workConnOpened = false;

            if (((workConnection.State & global::System.Data.ConnectionState.Broken)
                 == global::System.Data.ConnectionState.Broken))
            {
                workConnection.Close();
            }
            if ((workConnection.State == global::System.Data.ConnectionState.Closed))
            {
                workConnection.Open();
                workConnOpened = true;
            }
            global::System.Data.IDbTransaction workTransaction = workConnection.BeginTransaction();
            if ((workTransaction == null))
            {
                throw new global::System.ApplicationException("The transaction cannot begin. The current data connection does not support transa" +
                                                              "ctions or the current state is not allowing the transaction to begin.");
            }
            global::System.Collections.Generic.List <global::System.Data.DataRow>                     allChangedRows = new global::System.Collections.Generic.List <global::System.Data.DataRow>();
            global::System.Collections.Generic.List <global::System.Data.DataRow>                     allAddedRows   = new global::System.Collections.Generic.List <global::System.Data.DataRow>();
            global::System.Collections.Generic.List <global::System.Data.Common.DataAdapter>          adaptersWithAcceptChangesDuringUpdate = new global::System.Collections.Generic.List <global::System.Data.Common.DataAdapter>();
            global::System.Collections.Generic.Dictionary <object, global::System.Data.IDbConnection> revertConnections = new global::System.Collections.Generic.Dictionary <object, global::System.Data.IDbConnection>();
            int result = 0;

            global::System.Data.DataSet backupDataSet = null;
            if (this.BackupDataSetBeforeUpdate)
            {
                backupDataSet = new global::System.Data.DataSet();
                backupDataSet.Merge(dataSet);
            }
            try {
                // ---- Prepare for update -----------
                //
                //
                //---- Perform updates -----------
                //
                if ((this.UpdateOrder == UpdateOrderOption.UpdateInsertDelete))
                {
                    result = (result + this.UpdateUpdatedRows(dataSet, allChangedRows, allAddedRows));
                    result = (result + this.UpdateInsertedRows(dataSet, allAddedRows));
                }
                else
                {
                    result = (result + this.UpdateInsertedRows(dataSet, allAddedRows));
                    result = (result + this.UpdateUpdatedRows(dataSet, allChangedRows, allAddedRows));
                }
                result = (result + this.UpdateDeletedRows(dataSet, allChangedRows));
                //
                //---- Commit updates -----------
                //
                workTransaction.Commit();
                if ((0 < allAddedRows.Count))
                {
                    global::System.Data.DataRow[] rows = new System.Data.DataRow[allAddedRows.Count];
                    allAddedRows.CopyTo(rows);
                    for (int i = 0; (i < rows.Length); i = (i + 1))
                    {
                        global::System.Data.DataRow row = rows[i];
                        row.AcceptChanges();
                    }
                }
                if ((0 < allChangedRows.Count))
                {
                    global::System.Data.DataRow[] rows = new System.Data.DataRow[allChangedRows.Count];
                    allChangedRows.CopyTo(rows);
                    for (int i = 0; (i < rows.Length); i = (i + 1))
                    {
                        global::System.Data.DataRow row = rows[i];
                        row.AcceptChanges();
                    }
                }
            }
            catch (global::System.Exception ex) {
                workTransaction.Rollback();
                // ---- Restore the dataset -----------
                if (this.BackupDataSetBeforeUpdate)
                {
                    global::System.Diagnostics.Debug.Assert((backupDataSet != null));
                    dataSet.Clear();
                    dataSet.Merge(backupDataSet);
                }
                else
                {
                    if ((0 < allAddedRows.Count))
                    {
                        global::System.Data.DataRow[] rows = new System.Data.DataRow[allAddedRows.Count];
                        allAddedRows.CopyTo(rows);
                        for (int i = 0; (i < rows.Length); i = (i + 1))
                        {
                            global::System.Data.DataRow row = rows[i];
                            row.AcceptChanges();
                            row.SetAdded();
                        }
                    }
                }
                throw ex;
            }
            finally {
                if (workConnOpened)
                {
                    workConnection.Close();
                }
                if ((0 < adaptersWithAcceptChangesDuringUpdate.Count))
                {
                    global::System.Data.Common.DataAdapter[] adapters = new System.Data.Common.DataAdapter[adaptersWithAcceptChangesDuringUpdate.Count];
                    adaptersWithAcceptChangesDuringUpdate.CopyTo(adapters);
                    for (int i = 0; (i < adapters.Length); i = (i + 1))
                    {
                        global::System.Data.Common.DataAdapter adapter = adapters[i];
                        adapter.AcceptChangesDuringUpdate = true;
                    }
                }
            }
            return(result);
        }
        /// <summary>
        /// Create a shape of the given link shape type.
        /// </summary>
        /// <param name="shapeTypeId">Shape type id.</param>
        /// <param name="modelElement">Model element.</param>
		/// <param name="assignments">Properties for the shape.</param>
        /// <returns>Shape if one could be created. Null otherwise.</returns>
        public override DslModeling::ModelElement CreateShapeForElementLink(System.Guid shapeTypeId, DslModeling::ModelElement modelElement, params DslModeling::PropertyAssignment[] assignments)
		{
			
			DslEditorDiagrams::LinkShape nodeShape = null;	
		
			if( createRSShapeMap == null )
			{
				createRSShapeMap = new global::System.Collections.Generic.Dictionary<global::System.Guid, int>(2);
				createRSShapeMap.Add(global::Tum.FamilyTreeDSL.ParentOfShape.DomainClassId, 0);
				createRSShapeMap.Add(global::Tum.FamilyTreeDSL.MarriedToShape.DomainClassId, 1);
			}
			int index;
			if (!createRSShapeMap.TryGetValue(shapeTypeId, out index))
				throw new global::System.ArgumentException("Unrecognized shape type " + shapeTypeId.ToString());
			switch (index)
			{
				case 0: nodeShape = new global::Tum.FamilyTreeDSL.ParentOfShape(modelElement.Store, assignments); break;
				case 1: nodeShape = new global::Tum.FamilyTreeDSL.MarriedToShape(modelElement.Store, assignments); break;
				
			}

			if( nodeShape == null )
				throw new System.InvalidOperationException("Couldn't create shape of type " + shapeTypeId.ToString() + " for element link " + modelElement.ToString());
			
			nodeShape.Element = modelElement;
								
			return nodeShape;
		
        }
Пример #40
0
        /// <summary>
        /// Gets an array of CompartmentMappings for all compartments displayed on this shape
        /// (including compartment maps defined on base shapes).
        /// </summary>
        /// <param name="melType">The type of the DomainClass that this shape is mapped to</param>
        /// <returns></returns>
        protected override DslDiagrams::CompartmentMapping[] GetCompartmentMappings(global::System.Type melType)
        {
            if (melType == null)
            {
                throw new global::System.ArgumentNullException("melType");
            }

            if (compartmentMappings == null)
            {
                // Initialize the table of compartment mappings if we haven't done so already.
                // The table contains an array of CompartmentMapping for every Type that this
                // shape can be mapped to.
                compartmentMappings = new global::System.Collections.Generic.Dictionary <global::System.Type, DslDiagrams::CompartmentMapping[]>();
                {
                    // First we get the mappings defined for the base shape, and add on any mappings defined for this
                    // shape.
                    DslDiagrams::CompartmentMapping[] baseMappings = base.GetCompartmentMappings(typeof(global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityType));
                    int localCompartmentMappingsOffset             = 0;
                    if (baseMappings != null)
                    {
                        localCompartmentMappingsOffset = baseMappings.Length;
                    }
                    DslDiagrams::CompartmentMapping[] mappings = new DslDiagrams::CompartmentMapping[2 + localCompartmentMappingsOffset];

                    if (baseMappings != null)
                    {
                        baseMappings.CopyTo(mappings, 0);
                    }
                    mappings[localCompartmentMappingsOffset + 0] = new DslDiagrams::ElementListCompartmentMapping(
                        "Navigation",
                        global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.NameableItem.NameDomainPropertyId,
                        global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.NavigationProperty.DomainClassId,
                        GetElementsFromEntityTypeForNavigation,
                        null,
                        null,
                        null);
                    ////////
                    // CompartmentMap.DisplaysCustomString == true
                    // Please provide the following method to get the string to be
                    // displayed in the compartment list:
                    //
                    // static string GetDisplayPropertyFromEntityTypeForProperties(DslModeling::ModelElement element)
                    ////////
                    mappings[localCompartmentMappingsOffset + 1] = new DslDiagrams::ElementListCompartmentMapping(
                        "Properties",
                        global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.NameableItem.NameDomainPropertyId,
                        global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.Property.DomainClassId,
                        GetElementsFromEntityTypeForProperties,
                        null,
                        GetDisplayPropertyFromEntityTypeForProperties,                                                                                                                                          // This method needs to be provided. Please see comment-block above.
                        null);
                    compartmentMappings.Add(typeof(global::Microsoft.Data.Entity.Design.EntityDesigner.ViewModel.EntityType), mappings);
                }
            }

            // See if we can find the mapping being requested directly in the table.
            DslDiagrams::CompartmentMapping[] returnValue;
            if (compartmentMappings.TryGetValue(melType, out returnValue))
            {
                return(returnValue);
            }

            // If not, loop through the types in the table, and find the 'most derived' base
            // class of melType.
            global::System.Type selectedMappedType = null;
            foreach (global::System.Type mappedType in compartmentMappings.Keys)
            {
                if (mappedType.IsAssignableFrom(melType) && (selectedMappedType == null || selectedMappedType.IsAssignableFrom(mappedType)))
                {
                    selectedMappedType = mappedType;
                }
            }
            if (selectedMappedType != null)
            {
                return(compartmentMappings[selectedMappedType]);
            }
            return(new DslDiagrams::CompartmentMapping[] {});
        }
Пример #41
0
		public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementType == null) throw new global::System.ArgumentNullException("elementType");
	
			if (createElementMap == null)
			{
				createElementMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(14);
				createElementMap.Add(typeof(Model), 0);
				createElementMap.Add(typeof(ModelClass), 1);
				createElementMap.Add(typeof(ModelProperty), 2);
				createElementMap.Add(typeof(NestedClass), 3);
				createElementMap.Add(typeof(ActiveRecordMapping), 4);
				createElementMap.Add(typeof(ManyToOneConnector), 5);
				createElementMap.Add(typeof(ManyToManyConnector), 6);
				createElementMap.Add(typeof(OneToOneConnector), 7);
				createElementMap.Add(typeof(NestedConnector), 8);
				createElementMap.Add(typeof(InheritanceConnector), 9);
				createElementMap.Add(typeof(ClassShape), 10);
				createElementMap.Add(typeof(NestedClassShape), 11);
			}
			int index;
			if (!createElementMap.TryGetValue(elementType, out index))
			{
				// construct exception error message		
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::Castle.ActiveWriter.ActiveWriterDomainModel.SingletonResourceManager.GetString("UnrecognizedElementType"),
								elementType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementType");
			}
			switch (index)
			{
				case 0: return new Model(partition, propertyAssignments);
				case 1: return new ModelClass(partition, propertyAssignments);
				case 2: return new ModelProperty(partition, propertyAssignments);
				case 3: return new NestedClass(partition, propertyAssignments);
				case 4: return new ActiveRecordMapping(partition, propertyAssignments);
				case 5: return new ManyToOneConnector(partition, propertyAssignments);
				case 6: return new ManyToManyConnector(partition, propertyAssignments);
				case 7: return new OneToOneConnector(partition, propertyAssignments);
				case 8: return new NestedConnector(partition, propertyAssignments);
				case 9: return new InheritanceConnector(partition, propertyAssignments);
				case 10: return new ClassShape(partition, propertyAssignments);
				case 11: return new NestedClassShape(partition, propertyAssignments);
				default: return null;
			}
		}
Пример #42
0
 /// <summary>
 /// Get an entity of type global::Microsoft.Test.OData.Services.TestServices.PluggableFormatServiceReference.Product as global::Microsoft.Test.OData.Services.TestServices.PluggableFormatServiceReference.ProductSingle specified by key from an entity set
 /// </summary>
 /// <param name="source">source entity set</param>
 /// <param name="keys">dictionary with the names and values of keys</param>
 public static global::Microsoft.Test.OData.Services.TestServices.PluggableFormatServiceReference.ProductSingle ByKey(this global::Microsoft.OData.Client.DataServiceQuery <global::Microsoft.Test.OData.Services.TestServices.PluggableFormatServiceReference.Product> source, global::System.Collections.Generic.Dictionary <string, object> keys)
 {
     return(new global::Microsoft.Test.OData.Services.TestServices.PluggableFormatServiceReference.ProductSingle(source.Context, source.GetKeyPath(global::Microsoft.OData.Client.Serializer.GetKeyString(source.Context, keys))));
 }
Пример #43
0
		public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementType == null) throw new global::System.ArgumentNullException("elementType");
			
			if (createElementMap == null)
			{
				createElementMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(13);
				createElementMap.Add(typeof(VModell), 0);
				createElementMap.Add(typeof(VModellvariante), 1);
				createElementMap.Add(typeof(Referenzmodell), 2);
				createElementMap.Add(typeof(RolleDependencyShape), 3);
				createElementMap.Add(typeof(DisziplinDependencyShape), 4);
				createElementMap.Add(typeof(ErzAbhDependencyShape), 5);
				createElementMap.Add(typeof(Musterbibliothek), 6);
				createElementMap.Add(typeof(Mustergruppe), 7);
				createElementMap.Add(typeof(Themenmuster), 8);
				createElementMap.Add(typeof(Mustertext), 9);
				createElementMap.Add(typeof(Zusatzthema), 10);
				createElementMap.Add(typeof(Varianten), 11);
				createElementMap.Add(typeof(Variante), 12);
			}
			int index;
			if (!createElementMap.TryGetValue(elementType, out index))
			{
				// construct exception error message		
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::Tum.VModellXT.VModellXTDomainModel.SingletonResourceManager.GetString("UnrecognizedElementType"),
								elementType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementType");
			}
			switch (index)
			{
				case 0: return new VModell(partition, propertyAssignments);
				case 1: return new VModellvariante(partition, propertyAssignments);
				case 2: return new Referenzmodell(partition, propertyAssignments);
				case 3: return new RolleDependencyShape(partition, propertyAssignments);
				case 4: return new DisziplinDependencyShape(partition, propertyAssignments);
				case 5: return new ErzAbhDependencyShape(partition, propertyAssignments);
				case 6: return new Musterbibliothek(partition, propertyAssignments);
				case 7: return new Mustergruppe(partition, propertyAssignments);
				case 8: return new Themenmuster(partition, propertyAssignments);
				case 9: return new Mustertext(partition, propertyAssignments);
				case 10: return new Zusatzthema(partition, propertyAssignments);
				case 11: return new Varianten(partition, propertyAssignments);
				case 12: return new Variante(partition, propertyAssignments);
				default: return null;
			}
		}
Пример #44
0
        /// <summary>
        /// Gets an array of CompartmentMappings for all compartments displayed on this shape
        /// (including compartment maps defined on base shapes).
        /// </summary>
        /// <param name="melType">The type of the DomainClass that this shape is mapped to</param>
        /// <returns></returns>
        protected override DslDiagrams::CompartmentMapping[] GetCompartmentMappings(global::System.Type melType)
        {
            if (melType == null)
            {
                throw new global::System.ArgumentNullException("melType");
            }

            if (compartmentMappings == null)
            {
                // Initialize the table of compartment mappings if we haven't done so already.
                // The table contains an array of CompartmentMapping for every Type that this
                // shape can be mapped to.
                compartmentMappings = new global::System.Collections.Generic.Dictionary <global::System.Type, DslDiagrams::CompartmentMapping[]>();
                {
                    // First we get the mappings defined for the base shape, and add on any mappings defined for this
                    // shape.
                    DslDiagrams::CompartmentMapping[] baseMappings = base.GetCompartmentMappings(typeof(global::Altinoren.ActiveWriter.NestedClass));
                    int localCompartmentMappingsOffset             = 0;
                    if (baseMappings != null)
                    {
                        localCompartmentMappingsOffset = baseMappings.Length;
                    }
                    DslDiagrams::CompartmentMapping[] mappings = new DslDiagrams::CompartmentMapping[1 + localCompartmentMappingsOffset];

                    if (baseMappings != null)
                    {
                        baseMappings.CopyTo(mappings, 0);
                    }
                    mappings[localCompartmentMappingsOffset + 0] = new DslDiagrams::ElementListCompartmentMapping(
                        "Properties",
                        global::Altinoren.ActiveWriter.NamedElement.NameDomainPropertyId,
                        global::Altinoren.ActiveWriter.ModelProperty.DomainClassId,
                        GetElementsFromNestedClassForProperties,
                        null,
                        null,
                        null);
                    compartmentMappings.Add(typeof(global::Altinoren.ActiveWriter.NestedClass), mappings);
                }
            }

            // See if we can find the mapping being requested directly in the table.
            DslDiagrams::CompartmentMapping[] returnValue;
            if (compartmentMappings.TryGetValue(melType, out returnValue))
            {
                return(returnValue);
            }

            // If not, loop through the types in the table, and find the 'most derived' base
            // class of melType.
            global::System.Type selectedMappedType = null;
            foreach (global::System.Type mappedType in compartmentMappings.Keys)
            {
                if (mappedType.IsAssignableFrom(melType) && (selectedMappedType == null || selectedMappedType.IsAssignableFrom(mappedType)))
                {
                    selectedMappedType = mappedType;
                }
            }
            if (selectedMappedType != null)
            {
                return(compartmentMappings[selectedMappedType]);
            }
            return(new DslDiagrams::CompartmentMapping[] {});
        }
Пример #45
0
		public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementType == null) throw new global::System.ArgumentNullException("elementType");
	
			if (createElementMap == null)
			{
				createElementMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(8);
				createElementMap.Add(typeof(MappingCustomizationModel), 0);
				createElementMap.Add(typeof(AssimilationMapping), 1);
				createElementMap.Add(typeof(ReferenceModeNaming), 2);
				createElementMap.Add(typeof(DefaultReferenceModeNaming), 3);
				createElementMap.Add(typeof(RelationalNameGenerator), 4);
				createElementMap.Add(typeof(SchemaGenerationSetting), 5);
			}
			int index;
			if (!createElementMap.TryGetValue(elementType, out index))
			{
				throw new global::System.ArgumentException("elementType is not recognized as a type of domain class which belongs to this domain model.");
			}
			switch (index)
			{
				case 0: return new MappingCustomizationModel(partition, propertyAssignments);
				case 1: return new AssimilationMapping(partition, propertyAssignments);
				case 2: return new ReferenceModeNaming(partition, propertyAssignments);
				case 3: return new DefaultReferenceModeNaming(partition, propertyAssignments);
				// A constructor was not generated for RelationalNameGenerator because it had HasCustomConstructor
				// set to true. Please provide the constructor below.
				case 4: return new RelationalNameGenerator(partition, propertyAssignments);
				case 5: return new SchemaGenerationSetting(partition, propertyAssignments);
				default: return null;
			}
		}
Пример #46
0
 public RadarObstacles()
 {
     radar_obstacle = new global::System.Collections.Generic.Dictionary <int, RadarObstacle>();
     OnConstructor();
 }
		/// <summary>
		/// This method creates one SimpleMonikerResolver instance for each DomainModel used in serialization.
		/// </summary>
		/// <param name="store">Store on which moniker resolvers will be set up.</param>
		internal protected virtual global::System.Collections.Generic.IDictionary<global::System.Guid, DslModeling::IMonikerResolver> GetMonikerResolvers(DslModeling::Store store)
		{
			#region Check Parameters
			global::System.Diagnostics.Debug.Assert(store != null);
			if (store == null)
				throw new global::System.ArgumentNullException("store");
			#endregion
			
			global::System.Collections.Generic.Dictionary<global::System.Guid, DslModeling::IMonikerResolver> result = new global::System.Collections.Generic.Dictionary<global::System.Guid, DslModeling::IMonikerResolver>();
			result.Add(DslDiagrams::CoreDesignSurfaceDomainModel.DomainModelId, new DslDiagrams::CoreDesignSurfaceSerializationBehaviorMonikerResolver(store, this.Directory));
			result.Add(AsyncDslDomainModel.DomainModelId, new AsyncDslSerializationBehaviorMonikerResolver(store, this.Directory));
			return result;
		}
Пример #48
0
 public global::System.Threading.Tasks.Task SampleMethod(global::System.Collections.Generic.List <int> sampleList, global::System.Collections.Generic.Dictionary <int, string> sampleDictionary)
 {
     return(__parent.WriteMessageAsync <DynamicArgumentTuple <global::System.Collections.Generic.List <int>, global::System.Collections.Generic.Dictionary <int, string> > >(-852153394, new DynamicArgumentTuple <global::System.Collections.Generic.List <int>, global::System.Collections.Generic.Dictionary <int, string> >(sampleList, sampleDictionary)));
 }
Пример #49
0
		/// <summary>
		/// Construct the mapping from Moniker Xml tag name to DomainClassInfo that derives from ManyToOneRelation.
		/// </summary>
		/// <param name="serializationContext">Serialization context.</param>
		/// <param name="domainDataDirectory">DomainDataDirectory to be used to discover all derived classes.</param>
		private void ConstructDerivedClassMonikersLookupTable(DslModeling::SerializationContext serializationContext, DslModeling::DomainDataDirectory domainDataDirectory)
		{
			global::System.Diagnostics.Debug.Assert(derivedClassMonikers == null); // Shouldn't construct the table more than once.
			derivedClassMonikers = new global::System.Collections.Generic.Dictionary<string, DslModeling::DomainClassInfo> (global::System.StringComparer.CurrentCulture);
	
			DslModeling::DomainClassInfo thisClass = domainDataDirectory.GetDomainClass(ManyToOneRelation.DomainClassId);
			global::System.Diagnostics.Debug.Assert(thisClass != null, "Cannot find DomainClassInfo for ModelRoot!");
	
			global::System.Collections.ObjectModel.ReadOnlyCollection<DslModeling::DomainClassInfo> descendents = thisClass.AllDescendants;
			if (descendents != null)
			{
				foreach (DslModeling::DomainClassInfo descendent in descendents)
				{
					DslModeling::DomainClassXmlSerializer descendentSerializer = serializationContext.Directory.GetSerializer(descendent.Id);
					if (descendentSerializer != null)
					{
						string descendentMonikerTagName = descendentSerializer.MonikerTagName;
						if (!string.IsNullOrEmpty (descendentMonikerTagName))
						{
							global::System.Diagnostics.Debug.Assert(!derivedClassMonikers.ContainsKey (descendentMonikerTagName));
							derivedClassMonikers.Add (descendentMonikerTagName, descendent);
						}
					}
				}
			}
		}
Пример #50
0
 /// <summary>
 /// Get an entity of type global::EIV.Demo.Model.Client as global::EIV.Demo.Model.ClientSingle specified by key from an entity set
 /// </summary>
 /// <param name="source">source entity set</param>
 /// <param name="keys">dictionary with the names and values of keys</param>
 public static global::EIV.Demo.Model.ClientSingle ByKey(this global::Microsoft.OData.Client.DataServiceQuery <global::EIV.Demo.Model.Client> source, global::System.Collections.Generic.Dictionary <string, object> keys)
 {
     return(new global::EIV.Demo.Model.ClientSingle(source.Context, source.GetKeyPath(global::Microsoft.OData.Client.Serializer.GetKeyString(source.Context, keys))));
 }
Пример #51
0
		public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementType == null) throw new global::System.ArgumentNullException("elementType");
	
			if (createElementMap == null)
			{
				createElementMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(8);
				createElementMap.Add(typeof(SampleOrmModel), 0);
				createElementMap.Add(typeof(EntityElement), 1);
				createElementMap.Add(typeof(Property), 2);
				createElementMap.Add(typeof(Reference), 3);
				createElementMap.Add(typeof(OrmLanguageDiagram), 4);
				createElementMap.Add(typeof(EntityHasRelationShipsConnector), 5);
				createElementMap.Add(typeof(EntityShape), 6);
			}
			int index;
			if (!createElementMap.TryGetValue(elementType, out index))
			{
				// construct exception error message		
				string exceptionError = string.Format(
								global::System.Globalization.CultureInfo.CurrentCulture,
								global::Company.OrmLanguage.OrmLanguageDomainModel.SingletonResourceManager.GetString("UnrecognizedElementType"),
								elementType.Name);
				throw new global::System.ArgumentException(exceptionError, "elementType");
			}
			switch (index)
			{
				case 0: return new SampleOrmModel(partition, propertyAssignments);
				case 1: return new EntityElement(partition, propertyAssignments);
				case 2: return new Property(partition, propertyAssignments);
				case 3: return new Reference(partition, propertyAssignments);
				case 4: return new OrmLanguageDiagram(partition, propertyAssignments);
				case 5: return new EntityHasRelationShipsConnector(partition, propertyAssignments);
				case 6: return new EntityShape(partition, propertyAssignments);
				default: return null;
			}
		}
 /// <summary>
 /// Get an entity of type global::namespacePrefix.Namespace.Foo.SingleType as global::namespacePrefix.Namespace.Foo.SingleTypeSingle specified by key from an entity set
 /// </summary>
 /// <param name="source">source entity set</param>
 /// <param name="keys">dictionary with the names and values of keys</param>
 public static global::namespacePrefix.Namespace.Foo.SingleTypeSingle ByKey(this global::Microsoft.OData.Client.DataServiceQuery <global::namespacePrefix.Namespace.Foo.SingleType> source, global::System.Collections.Generic.Dictionary <string, object> keys)
 {
     return(new global::namespacePrefix.Namespace.Foo.SingleTypeSingle(source.Context, source.GetKeyPath(global::Microsoft.OData.Client.Serializer.GetKeyString(source.Context, keys))));
 }
Пример #53
0
		public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
		{
			if (elementType == null) throw new global::System.ArgumentNullException("elementType");
	
			if (createElementMap == null)
			{
				createElementMap = new global::System.Collections.Generic.Dictionary<global::System.Type, int>(3);
				createElementMap.Add(typeof(CustomPropertyGroup), 0);
				createElementMap.Add(typeof(CustomPropertyDefinition), 1);
				createElementMap.Add(typeof(CustomProperty), 2);
			}
			int index;
			if (!createElementMap.TryGetValue(elementType, out index))
			{
				throw new global::System.ArgumentException("elementType is not recognized as a type of domain class which belongs to this domain model.");
			}
			switch (index)
			{
				case 0: return new CustomPropertyGroup(partition, propertyAssignments);
				case 1: return new CustomPropertyDefinition(partition, propertyAssignments);
				case 2: return new CustomProperty(partition, propertyAssignments);
				default: return null;
			}
		}
Пример #54
0
        public sealed override DslModeling::ModelElement CreateElement(DslModeling::Partition partition, global::System.Type elementType, DslModeling::PropertyAssignment[] propertyAssignments)
        {
            if (elementType == null)
            {
                throw new global::System.ArgumentNullException("elementType");
            }

            if (createElementMap == null)
            {
                createElementMap = new global::System.Collections.Generic.Dictionary <global::System.Type, int>(24);
                createElementMap.Add(typeof(DataContractModel), 0);
                createElementMap.Add(typeof(DataContract), 1);
                createElementMap.Add(typeof(ModelElementReference), 2);
                createElementMap.Add(typeof(PrimitiveDataType), 3);
                createElementMap.Add(typeof(FaultContract), 4);
                createElementMap.Add(typeof(DataContractCollection), 5);
                createElementMap.Add(typeof(DataContractEnum), 6);
                createElementMap.Add(typeof(EnumNamedValue), 7);
                createElementMap.Add(typeof(PrimitiveDataTypeCollection), 8);
                createElementMap.Add(typeof(ReferenceDataType), 9);
                createElementMap.Add(typeof(DataContractDiagram), 10);
                createElementMap.Add(typeof(DataContractAggregationConnector), 11);
                createElementMap.Add(typeof(ReferenceConnector), 12);
                createElementMap.Add(typeof(AggregationConnector), 13);
                createElementMap.Add(typeof(DataContractCollectionShape), 14);
                createElementMap.Add(typeof(PrimitiveDataTypeCollectionShape), 15);
                createElementMap.Add(typeof(DataContractCompartmentShape), 16);
                createElementMap.Add(typeof(FaultContractCompartmentShape), 17);
                createElementMap.Add(typeof(DataContractEnumCompartmentShape), 18);
            }
            int index;

            if (!createElementMap.TryGetValue(elementType, out index))
            {
                // construct exception error message
                string exceptionError = string.Format(
                    global::System.Globalization.CultureInfo.CurrentCulture,
                    global::Microsoft.Practices.ServiceFactory.DataContracts.DataContractDslDomainModel.SingletonResourceManager.GetString("UnrecognizedElementType"),
                    elementType.Name);
                throw new global::System.ArgumentException(exceptionError, "elementType");
            }
            switch (index)
            {
            case 0: return(new DataContractModel(partition, propertyAssignments));

            case 1: return(new DataContract(partition, propertyAssignments));

            case 2: return(new ModelElementReference(partition, propertyAssignments));

            case 3: return(new PrimitiveDataType(partition, propertyAssignments));

            case 4: return(new FaultContract(partition, propertyAssignments));

            case 5: return(new DataContractCollection(partition, propertyAssignments));

            case 6: return(new DataContractEnum(partition, propertyAssignments));

            case 7: return(new EnumNamedValue(partition, propertyAssignments));

            case 8: return(new PrimitiveDataTypeCollection(partition, propertyAssignments));

            case 9: return(new ReferenceDataType(partition, propertyAssignments));

            case 10: return(new DataContractDiagram(partition, propertyAssignments));

            case 11: return(new DataContractAggregationConnector(partition, propertyAssignments));

            case 12: return(new ReferenceConnector(partition, propertyAssignments));

            case 13: return(new AggregationConnector(partition, propertyAssignments));

            case 14: return(new DataContractCollectionShape(partition, propertyAssignments));

            case 15: return(new PrimitiveDataTypeCollectionShape(partition, propertyAssignments));

            case 16: return(new DataContractCompartmentShape(partition, propertyAssignments));

            case 17: return(new FaultContractCompartmentShape(partition, propertyAssignments));

            case 18: return(new DataContractEnumCompartmentShape(partition, propertyAssignments));

            default: return(null);
            }
        }
Пример #55
0
		/// <summary>
		/// Gets an array of CompartmentMappings for all compartments displayed on this shape
		/// (including compartment maps defined on base shapes). 
		/// </summary>
		/// <param name="melType">The type of the DomainClass that this shape is mapped to</param>
		/// <returns></returns>
		protected override DslDiagrams::CompartmentMapping[] GetCompartmentMappings(global::System.Type melType)
		{
			if(melType==null) throw new global::System.ArgumentNullException("melType");
			
			if(compartmentMappings==null)
			{
				// Initialize the table of compartment mappings if we haven't done so already. 
				// The table contains an array of CompartmentMapping for every Type that this
				// shape can be mapped to. 
				compartmentMappings = new global::System.Collections.Generic.Dictionary<global::System.Type, DslDiagrams::CompartmentMapping[]>();
				{
					// First we get the mappings defined for the base shape, and add on any mappings defined for this
					// shape. 
					DslDiagrams::CompartmentMapping[] baseMappings = base.GetCompartmentMappings(typeof(global::LinqToRdf.Design.ModelInterface));
					int localCompartmentMappingsOffset = 0;
					if(baseMappings!=null)
					{
						localCompartmentMappingsOffset = baseMappings.Length;
					}
					DslDiagrams::CompartmentMapping[] mappings = new DslDiagrams::CompartmentMapping[1+localCompartmentMappingsOffset];
					
					if(baseMappings!=null)
					{
						baseMappings.CopyTo(mappings, 0);
					}
					mappings[localCompartmentMappingsOffset+0] = new DslDiagrams::ElementListCompartmentMapping(
																				"OperationsCompartment", 
																				global::LinqToRdf.Design.NamedElement.NameDomainPropertyId, 
																				global::LinqToRdf.Design.InterfaceOperation.DomainClassId, 
																				GetElementsFromModelInterfaceForOperationsCompartment,
																				null,
																				null,
																				null);
					compartmentMappings.Add(typeof(global::LinqToRdf.Design.ModelInterface), mappings);
				}
			}
			
			// See if we can find the mapping being requested directly in the table. 
			DslDiagrams::CompartmentMapping[] returnValue;
			if(compartmentMappings.TryGetValue(melType, out returnValue))
			{
				return returnValue;
			}
			
			// If not, loop through the types in the table, and find the 'most derived' base
			// class of melType. 
			global::System.Type selectedMappedType = null;
			foreach(global::System.Type mappedType in compartmentMappings.Keys)
			{
				if(mappedType.IsAssignableFrom(melType) && (selectedMappedType==null || selectedMappedType.IsAssignableFrom(mappedType)))
				{
					selectedMappedType = mappedType;
				}
			}
			if(selectedMappedType!=null)
			{
				return compartmentMappings[selectedMappedType];
			}
			return new DslDiagrams::CompartmentMapping[] {};
		}
Пример #56
0
        public sealed override DslModeling::ElementLink CreateElementLink(DslModeling::Partition partition, global::System.Type elementLinkType, DslModeling::RoleAssignment[] roleAssignments, DslModeling::PropertyAssignment[] propertyAssignments)
        {
            if (elementLinkType == null)
            {
                throw new global::System.ArgumentNullException("elementLinkType");
            }
            if (roleAssignments == null)
            {
                throw new global::System.ArgumentNullException("roleAssignments");
            }

            if (createElementLinkMap == null)
            {
                createElementLinkMap = new global::System.Collections.Generic.Dictionary <global::System.Type, int>(14);
                createElementLinkMap.Add(typeof(AssimilationMappingCustomizesFactType), 0);
                createElementLinkMap.Add(typeof(MappingCustomizationModelHasAssimilationMapping), 1);
                createElementLinkMap.Add(typeof(ReferenceModeNamingCustomizesObjectType), 2);
                createElementLinkMap.Add(typeof(MappingCustomizationModelHasReferenceModeNaming), 3);
                createElementLinkMap.Add(typeof(DefaultReferenceModeNamingCustomizesORMModel), 4);
                createElementLinkMap.Add(typeof(MappingCustomizationModelHasDefaultReferenceModeNaming), 5);
                createElementLinkMap.Add(typeof(SchemaIsForAbstractionModel), 6);
                createElementLinkMap.Add(typeof(TableIsPrimarilyForConceptType), 7);
                createElementLinkMap.Add(typeof(TableIsAlsoForConceptType), 8);
                createElementLinkMap.Add(typeof(TableIsAlsoForConceptTypeHasAssimilationPath), 9);
                createElementLinkMap.Add(typeof(ColumnHasConceptTypeChild), 10);
                createElementLinkMap.Add(typeof(UniquenessConstraintIsForUniqueness), 11);
                createElementLinkMap.Add(typeof(DomainIsForInformationTypeFormat), 12);
                createElementLinkMap.Add(typeof(GenerationSettingTargetsSchema), 13);
            }
            int index;

            if (!createElementLinkMap.TryGetValue(elementLinkType, out index))
            {
                // construct exception error message
                string exceptionError = string.Format(
                    global::System.Globalization.CultureInfo.CurrentCulture,
                    global::ORMSolutions.ORMArchitect.ORMAbstractionToConceptualDatabaseBridge.ORMAbstractionToConceptualDatabaseBridgeDomainModel.SingletonResourceManager.GetString("UnrecognizedElementLinkType"),
                    elementLinkType.Name);
                throw new global::System.ArgumentException(exceptionError, "elementLinkType");
            }
            switch (index)
            {
            case 0: return(new AssimilationMappingCustomizesFactType(partition, roleAssignments, propertyAssignments));

            case 1: return(new MappingCustomizationModelHasAssimilationMapping(partition, roleAssignments, propertyAssignments));

            case 2: return(new ReferenceModeNamingCustomizesObjectType(partition, roleAssignments, propertyAssignments));

            case 3: return(new MappingCustomizationModelHasReferenceModeNaming(partition, roleAssignments, propertyAssignments));

            case 4: return(new DefaultReferenceModeNamingCustomizesORMModel(partition, roleAssignments, propertyAssignments));

            case 5: return(new MappingCustomizationModelHasDefaultReferenceModeNaming(partition, roleAssignments, propertyAssignments));

            case 6: return(new SchemaIsForAbstractionModel(partition, roleAssignments, propertyAssignments));

            case 7: return(new TableIsPrimarilyForConceptType(partition, roleAssignments, propertyAssignments));

            case 8: return(new TableIsAlsoForConceptType(partition, roleAssignments, propertyAssignments));

            case 9: return(new TableIsAlsoForConceptTypeHasAssimilationPath(partition, roleAssignments, propertyAssignments));

            case 10: return(new ColumnHasConceptTypeChild(partition, roleAssignments, propertyAssignments));

            case 11: return(new UniquenessConstraintIsForUniqueness(partition, roleAssignments, propertyAssignments));

            case 12: return(new DomainIsForInformationTypeFormat(partition, roleAssignments, propertyAssignments));

            case 13: return(new GenerationSettingTargetsSchema(partition, roleAssignments, propertyAssignments));

            default: return(null);
            }
        }
Пример #57
0
public virtual void Initialize()
{
    if ((this.Errors.HasErrors == false))
    {
bool namespceValueAcquired = false;
if (this.Session.ContainsKey("namespce"))
{
    if ((typeof(string).IsAssignableFrom(this.Session["namespce"].GetType()) == false))
    {
        this.Error("The type \'System.String\' of the parameter \'namespce\' did not match the type of th" +
                "e data passed to the template.");
    }
    else
    {
        this._namespceField = ((string)(this.Session["namespce"]));
        namespceValueAcquired = true;
    }
}
if ((namespceValueAcquired == false))
{
    object data = global::System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("namespce");
    if ((data != null))
    {
        if ((typeof(string).IsAssignableFrom(data.GetType()) == false))
        {
            this.Error("The type \'System.String\' of the parameter \'namespce\' did not match the type of th" +
                    "e data passed to the template.");
        }
        else
        {
            this._namespceField = ((string)(data));
        }
    }
}
bool modelNamespaceValueAcquired = false;
if (this.Session.ContainsKey("modelNamespace"))
{
    if ((typeof(string).IsAssignableFrom(this.Session["modelNamespace"].GetType()) == false))
    {
        this.Error("The type \'System.String\' of the parameter \'modelNamespace\' did not match the type" +
                " of the data passed to the template.");
    }
    else
    {
        this._modelNamespaceField = ((string)(this.Session["modelNamespace"]));
        modelNamespaceValueAcquired = true;
    }
}
if ((modelNamespaceValueAcquired == false))
{
    object data = global::System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("modelNamespace");
    if ((data != null))
    {
        if ((typeof(string).IsAssignableFrom(data.GetType()) == false))
        {
            this.Error("The type \'System.String\' of the parameter \'modelNamespace\' did not match the type" +
                    " of the data passed to the template.");
        }
        else
        {
            this._modelNamespaceField = ((string)(data));
        }
    }
}
bool classNameValueAcquired = false;
if (this.Session.ContainsKey("className"))
{
    if ((typeof(string).IsAssignableFrom(this.Session["className"].GetType()) == false))
    {
        this.Error("The type \'System.String\' of the parameter \'className\' did not match the type of t" +
                "he data passed to the template.");
    }
    else
    {
        this._classNameField = ((string)(this.Session["className"]));
        classNameValueAcquired = true;
    }
}
if ((classNameValueAcquired == false))
{
    object data = global::System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("className");
    if ((data != null))
    {
        if ((typeof(string).IsAssignableFrom(data.GetType()) == false))
        {
            this.Error("The type \'System.String\' of the parameter \'className\' did not match the type of t" +
                    "he data passed to the template.");
        }
        else
        {
            this._classNameField = ((string)(data));
        }
    }
}
bool connectionValueAcquired = false;
if (this.Session.ContainsKey("connection"))
{
    if ((typeof(string).IsAssignableFrom(this.Session["connection"].GetType()) == false))
    {
        this.Error("The type \'System.String\' of the parameter \'connection\' did not match the type of " +
                "the data passed to the template.");
    }
    else
    {
        this._connectionField = ((string)(this.Session["connection"]));
        connectionValueAcquired = true;
    }
}
if ((connectionValueAcquired == false))
{
    object data = global::System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("connection");
    if ((data != null))
    {
        if ((typeof(string).IsAssignableFrom(data.GetType()) == false))
        {
            this.Error("The type \'System.String\' of the parameter \'connection\' did not match the type of " +
                    "the data passed to the template.");
        }
        else
        {
            this._connectionField = ((string)(data));
        }
    }
}
bool tablesValueAcquired = false;
if (this.Session.ContainsKey("tables"))
{
    if ((typeof(global::System.Collections.Generic.Dictionary<System.String, System.String>).IsAssignableFrom(this.Session["tables"].GetType()) == false))
    {
        this.Error("The type \'System.Collections.Generic.Dictionary<System.String, System.String>\' of" +
                " the parameter \'tables\' did not match the type of the data passed to the templat" +
                "e.");
    }
    else
    {
        this._tablesField = ((global::System.Collections.Generic.Dictionary<System.String, System.String>)(this.Session["tables"]));
        tablesValueAcquired = true;
    }
}
if ((tablesValueAcquired == false))
{
    object data = global::System.Runtime.Remoting.Messaging.CallContext.LogicalGetData("tables");
    if ((data != null))
    {
        if ((typeof(global::System.Collections.Generic.Dictionary<System.String, System.String>).IsAssignableFrom(data.GetType()) == false))
        {
            this.Error("The type \'System.Collections.Generic.Dictionary<System.String, System.String>\' of" +
                    " the parameter \'tables\' did not match the type of the data passed to the templat" +
                    "e.");
        }
        else
        {
            this._tablesField = ((global::System.Collections.Generic.Dictionary<System.String, System.String>)(data));
        }
    }
}


    }
}
 /// <summary>
 /// Gets an EntityQuery instance that can be used to load <see cref="Region"/> entity instances using the 'GetRegionById' query.
 /// </summary>
 /// <param name="id">The value for the 'id' parameter of the query.</param>
 /// <returns>An EntityQuery that can be loaded to retrieve <see cref="Region"/> entity instances.</returns>
 public global::OpenRiaServices.DomainServices.Client.EntityQuery<global::DbContextModels.Northwind.Region> GetRegionByIdQuery(int id)
 {
     global::System.Collections.Generic.Dictionary<string, object> parameters = new global::System.Collections.Generic.Dictionary<string, object>();
     parameters.Add("id", id);
     this.ValidateMethod("GetRegionByIdQuery", parameters);
     return base.CreateQuery<global::DbContextModels.Northwind.Region>("GetRegionById", parameters, false, false);
 }
Пример #59
0
 public void AddEnumValue(string name, object value)
 {
     if (_enumValues == null)
     {
         _enumValues = new global::System.Collections.Generic.Dictionary<string, object>();
     }
     _enumValues.Add(name, value);
 }
Пример #60
0
        private global::Ice.AsyncResult <Callback_Worker_PerformActionEx> begin_PerformActionEx(OperationType iceP_operation, int iceP_contentSizeMB, global::System.Collections.Generic.Dictionary <string, string> context, global::Ice.AsyncCallback completedCallback, object cookie, bool synchronous)
        {
            iceCheckAsyncTwowayOnly(_PerformActionEx_name);
            var completed = new global::IceInternal.OperationAsyncResultCompletionCallback <Callback_Worker_PerformActionEx, OperationResult>(
                (Callback_Worker_PerformActionEx cb, OperationResult ret) =>
            {
                if (cb != null)
                {
                    cb.Invoke(ret);
                }
            },
                this, _PerformActionEx_name, cookie, completedCallback);

            _iceI_PerformActionEx(iceP_operation, iceP_contentSizeMB, context, synchronous, completed);
            return(completed);
        }