private bool InheritFromSuperField(MetaMetadataRepository repository, InheritanceHandler inheritanceHandler) { bool inhertedIsInheriting = false; MetaMetadataCompositeField inheritedField = (MetaMetadataCompositeField)SuperField; if (inheritedField != null) { inheritedField.Repository = repository; if (inheritedField.InheritInProcess) { inhertedIsInheriting = true; // if inheriting from the root mmd, we need to clone and keep the environment right now. InheritanceHandler inheritanceHandlerToUse = inheritanceHandler.clone(); inheritanceHandler.Pop(this); //inheritedField.InheritFinished += (sender, e) => InheritFrom(repository, inheritedField); this.AddInheritanceFinishHandler(inheritedField, InheritFieldFinished, inheritanceHandlerToUse); } else { inheritedField.InheritMetaMetadata(inheritanceHandler); InheritFromCompositeField(inheritedField, repository, inheritanceHandler); } } return(inhertedIsInheriting); }
protected override MetaMetadata FindOrGenerateInheritedMetaMetadata(MetaMetadataRepository repository, InheritanceHandler inheritanceHandler) { if (MetaMetadata.IsRootMetaMetadata(this)) { return(null); } MetaMetadata inheritedMmd = this.TypeMmd; if (inheritedMmd == null) { String inheritedMmdName = this.Type; if (inheritedMmdName == null) { inheritedMmdName = this.ExtendsAttribute; SetNewMetadataClass(true); } if (inheritedMmdName == null) { throw new MetaMetadataException("no type/extends specified: " + this); } inheritedMmd = (MetaMetadata)this.Scope[inheritedMmdName]; if (inheritedMmd == null) { throw new MetaMetadataException("meta-metadata '" + inheritedMmdName + "' not found."); } TypeMmd = inheritedMmd; } return(inheritedMmd); }
public static async Task <MetaMetadataRepository> ReadDirectoryRecursively(MetaMetadataRepository mainRepo, String path, SimplTypesScope mmdTScope, SimplTypesScope metadataTScope) { Stack <string> stack = new Stack <string>(); stack.Push(path); while (stack.Count > 0) { string dir = stack.Pop(); Debug.WriteLine("Looking in : " + dir); //String[] files = Directory.GetFiles(dir, "*.xml"); string[] files = await FundamentalPlatformSpecifics.Get().GetFilesFromDirectory(dir, ".xml"); foreach (string file in files) { MetaMetadataRepository thatRepo = await ReadRepository(file, mmdTScope, metadataTScope, mainRepo); // if (thatRepo != null) // mainRepo.IntegrateRepository(thatRepo); //string[] directories = Directory.GetDirectories(dir); // string[] directories = await FundamentalPlatformSpecifics.Get().GetDirectoriesFromDirectory(dir); // foreach ( // string innerDir in directories.Where( // innerDir => // !innerDir.Contains(".svn"))) // stack.Push(innerDir); // }); } } return(mainRepo); }
private void InitializeRepositoryAndPerformBinding() { META_METADATA_REPOSITORY = _metaMetadataRepository; SetDefaultMetaMetadatas(); BindAndCallback(META_METADATA_REPOSITORY); }
/// <summary> /// Integrate the contents of otherRepository with this one. /// </summary> /// <param name="repository"></param> public void IntegrateRepository(MetaMetadataRepository repository) { // combine userAgents if (!MergeDictionaries(repository.userAgents, this.userAgents)) { this.userAgents = repository.userAgents; } // combine searchEngines if (!MergeDictionaries(repository.searchEngines, this.searchEngines)) { this.searchEngines = repository.searchEngines; } // combine namedStyles if (!MergeDictionaries(repository.namedStyles, this.namedStyles)) { this.namedStyles = repository.namedStyles; } // combine sites if (!MergeDictionaries(repository.sites, this.sites)) { this.sites = repository.sites; } if (!MergeDictionaries(repository._repositoryByMime, this._repositoryByMime)) { this._repositoryByMime = repository._repositoryByMime; } if (!MergeDictionaries(repository._repositoryBySuffix, this._repositoryBySuffix)) { this._repositoryBySuffix = repository._repositoryBySuffix; } Dictionary <String, MetaMetadata> otherRepositoryByTagName = repository._repositoryByName; //set metaMetadata to have the correct parent repository in ElementState if (otherRepositoryByTagName != null) { foreach (MetaMetadata mmd in otherRepositoryByTagName.Values) { mmd.Parent = this; if (mmd.PackageName == null) { mmd.PackageName = repository.packageName; } } if (!MergeDictionaries(otherRepositoryByTagName, this._repositoryByName)) { this._repositoryByName = otherRepositoryByTagName; } } //MetadataTScope = repository.MetadataTScope; }
public async Task <MetaMetadataRepository> LoadRepositoryFromCache(object file) { _metaMetadataRepository = await MetaMetadataTranslationScope.Get().Deserialize(file, Format.Xml) as MetaMetadataRepository; InitializeRepositoryAndPerformBinding(); return(_metaMetadataRepository); }
private void BindAndCallback(MetaMetadataRepository repository) { if (repository != null) { repository.BindMetadataClassDescriptorsToMetaMetadata(_metadataTranslationScope); } if (RepositoryLoaded != null) { RepositoryLoaded(repository, new EventArgs()); } }
public async Task <MetaMetadataRepository> LoadRepositoryFromServiceAsync(ParsedUri serviceUri, object cacheFile = null) { _metaMetadataRepository = (serviceUri != null) ? await RequestMetaMetadataRepository(new ParsedUri(serviceUri, "mmdrepository.xml")) : new MetaMetadataRepository(); if (cacheFile != null) { SimplTypesScope.Serialize(_metaMetadataRepository, cacheFile, Format.Xml); } InitializeRepositoryAndPerformBinding(); return(_metaMetadataRepository); }
public static async Task <MetaMetadataRepository> RequestMetaMetadataRepository(ParsedUri requestUri) { MetaMetadataRepository repository = null; try { repository = await MetaMetadataTranslationScope.Get().DeserializeUri(requestUri, Format.Xml, new TranslationContext(requestUri)) as MetaMetadataRepository; } catch (Exception) { Debug.WriteLine("Error loading Meta-metadata Repo. Service is down?!"); } return(repository); }
public static String GetMdClassNameFromMmdOrNoChange(String mmdName, MetaMetadataRepository repository, MmdCompilerService compilerService) { MetaMetadata mmd = repository.GetMMByName(mmdName); if (mmd == null) { return(mmdName); } else { MetadataClassDescriptor metadataClassDescriptor = mmd.MetadataClassDescriptor; if (compilerService != null) { compilerService.AddCurrentClassDependency(metadataClassDescriptor); } return(metadataClassDescriptor.DescribedClassSimpleName); } }
protected override bool InheritMetaMetadataHelper(InheritanceHandler inheritanceHandler) { inheritanceHandler.Push(this); bool inhertedIsInheriting = false; // init MetaMetadataRepository repository = Repository; // determine the structure we should inherit from MetaMetadata inheritedMmd = FindOrGenerateInheritedMetaMetadata(repository, inheritanceHandler); if (inheritedMmd != null) { if (inheritedMmd.InheritInProcess) { inhertedIsInheriting = true; // if inheriting from the root mmd, we need to clone and keep the environment right now. InheritanceHandler inheritanceHandlerToUse = inheritanceHandler.clone(); inheritanceHandler.Pop(this); //inheritedMmd.InheritFinished += (sender, e) => InheritFromTopLevelMetaMetadata(inheritedMmd, repository); this.AddInheritanceFinishHandler(inheritedMmd, InheritMetaMetadataFinished, inheritanceHandlerToUse); } else { inheritedMmd.InheritMetaMetadata(null); //edit InheritFromTopLevelMetaMetadata(inheritedMmd, repository, inheritanceHandler); } } if (!inhertedIsInheriting) { inhertedIsInheriting = InheritFromSuperField(repository, inheritanceHandler); } // for the root meta-metadata, this may happend if (inheritedMmd == null && SuperField == null) { InheritFrom(repository, null, inheritanceHandler); } return(!inhertedIsInheriting); }
protected override void InheritFrom(MetaMetadataRepository repository, MetaMetadataCompositeField inheritedStructure, InheritanceHandler inheritanceHandler) { base.InheritFrom(repository, inheritedStructure, inheritanceHandler); // for fields referring to this meta-metadata type // need to do inheritMetaMetadata() again after copying fields from this.getInheritedMmd() /* foreach (MetaMetadataField f in this.Kids.Values) * { * if (f.GetType() == typeof(MetaMetadataNestedField)) * { * MetaMetadataNestedField nested = (MetaMetadataNestedField) f; * if (nested.InheritedMmd == this) * { * nested.ClearInheritFinishedOrInProgressFlag(); * nested.InheritMetaMetadata(); * } * } * } */ }
public async void LoadRepositoryAsync() { META_METADATA_REPOSITORY = new MetaMetadataRepository { RepositoryByName = new Dictionary <string, MetaMetadata>(), PackageMmdScopes = new Dictionary <string, MmdScope>() }; _metaMetadataRepository = META_METADATA_REPOSITORY; SetDefaultMetaMetadatas(); MetaMetadataRepository mainRepo = await MetaMetadataRepositoryLoader.ReadDirectoryRecursively( META_METADATA_REPOSITORY, MetametadataRepositoryDirFile as string, MetaMetadataTranslationScope.Get(), _metadataTranslationScope ); BindAndCallback(mainRepo); }
public static async Task <MetaMetadataRepository> ReadRepository(string filename, SimplTypesScope mmdTScope, SimplTypesScope metadataTScope, MetaMetadataRepository mainRepo) { MetaMetadataRepository repo = null; Debug.WriteLine("MetaMetadataRepository Reading:\t\t" + filename); try { repo = await mmdTScope.DeserializeFile(filename, Format.Xml) as MetaMetadataRepository; if (repo != null) { repo.MetadataTScope = metadataTScope; repo.File = filename; repo.InitializeSuffixAndMimeDicts(); if (repo.RepositoryByName == null) { return(repo); } foreach (var repoEntry in repo.RepositoryByName) { MetaMetadata mmd = repoEntry.Value; string mmdName = repoEntry.Key; //mmd.File = new FileInfo(filename); mmd.File = await FundamentalPlatformSpecifics.Get().CreateFile(filename); mmd.Parent = mainRepo; mmd.Repository = mainRepo; string packageName = mmd.PackageName ?? repo.PackageName; if (packageName == null) { throw new MetaMetadataException("No Package Name Specified For " + mmd); } mmd.PackageName = packageName; MmdScope packageMmdScopes; mainRepo.PackageMmdScopes.TryGetValue(mmd.PackageName, out packageMmdScopes); if (packageMmdScopes == null) { packageMmdScopes = new MmdScope(repo.PackageName); packageMmdScopes.PutAll(mainRepo.RepositoryByName); mainRepo.PackageMmdScopes.Put(packageName, packageMmdScopes); } MetaMetadata existingMmd; switch (mmd.Visibility) { case Visibility.GLOBAL: mainRepo.RepositoryByName.TryGetValue(mmdName, out existingMmd); if (existingMmd != null && existingMmd != mmd) { throw new MetaMetadataException("MMD already exists: " + mmdName + " in " + filename); } mainRepo.RepositoryByName.Put(mmdName, mmd); break; case Visibility.PACKAGE: Object mmdObj = null; packageMmdScopes.TryGetValue(mmdName, out mmdObj); existingMmd = (MetaMetadata)mmdObj; if (existingMmd != null && existingMmd != mmd) { throw new MetaMetadataException("MMD already exists: " + mmdName + " in " + filename); } packageMmdScopes.Put(mmdName, mmd); break; } } foreach (MetaMetadata metaMetadata in repo.RepositoryByName.Values) { if (metaMetadata.PackageName == null) { Debug.WriteLine("No Package name defined for: " + metaMetadata.Name); continue; } MmdScope packageMmdScope; mainRepo.PackageMmdScopes.TryGetValue(metaMetadata.PackageName, out packageMmdScope); metaMetadata.Scope = packageMmdScope; } mainRepo.IntegrateRepository(repo); } } catch (Exception e) { Debug.WriteLine("Couldn't translate repository file: " + filename); Debug.WriteLine(e); } return(repo); }
private void InheritFromCompositeField(MetaMetadataCompositeField inheritedField, MetaMetadataRepository repository, InheritanceHandler inheritanceHandler) { InheritFrom(repository, inheritedField, inheritanceHandler); }
private void InheritFromTopLevelMetaMetadata(MetaMetadata inheritedMmd, MetaMetadataRepository repository, InheritanceHandler inheritanceHandler) { InheritNonFieldElements(inheritedMmd, inheritanceHandler); InheritFrom(repository, inheritedMmd, inheritanceHandler); }
protected virtual void InheritFrom(MetaMetadataRepository repository, MetaMetadataCompositeField inheritedStructure, InheritanceHandler inheritanceHandler) { // init nested fields inside this var subfields = Kids.Values; foreach (MetaMetadataField f in subfields) { if (f is MetaMetadataNestedField) { f.Repository = (repository); MetaMetadataNestedField nested = (MetaMetadataNestedField)f; if (nested.PackageName == null) { nested.PackageName = PackageName; } nested.Scope = Scope; } } // inherit fields with attributes from inheritedStructure // if inheritedStructure == null, this must be the root meta-metadata if (inheritedStructure != null) { var inheritedStructSubfields = inheritedStructure.Kids.Values; foreach (MetaMetadataField field in inheritedStructSubfields) { if (field is MetaMetadataNestedField) { ((MetaMetadataNestedField)field).InheritMetaMetadata(inheritanceHandler); } string fieldName = field.Name; MetaMetadataField fieldLocal; kids.TryGetValue(fieldName, out fieldLocal); if (fieldLocal == null && inheritanceHandler.IsUsingGenerics(field)) { // if the super field is using generics, we will need to re-evaluate generic type vars fieldLocal = (MetaMetadataField)Activator.CreateInstance(field.GetType()); //Prepare Child Field For Inheritance fieldLocal.Repository = (repository); if (fieldLocal is MetaMetadataNestedField) { MetaMetadataNestedField nested = (MetaMetadataNestedField)fieldLocal; if (nested.PackageName == null) { nested.PackageName = PackageName; } nested.Scope = Scope; } } if (fieldLocal != null) { Debug.WriteLine("inheriting field: " + fieldLocal + " <= " + field); if (field.GetType() != fieldLocal.GetType()) { Debug.WriteLine("local field " + fieldLocal + " hides field " + fieldLocal + " with the same name in super mmd type!"); } // debug("inheriting field " + fieldLocal + " from " + field); if (field != fieldLocal) { fieldLocal.SuperField = field; } fieldLocal.DeclaringMmd = field.DeclaringMmd; fieldLocal.InheritAttributes(field); if (fieldLocal is MetaMetadataNestedField) { ((MetaMetadataNestedField)fieldLocal).PackageName = ((MetaMetadataNestedField)field).PackageName; } } } } // recursively call inheritMetaMetadata() on nested fields foreach (MetaMetadataField f in subfields) { // a new field is defined inside this mmd if (f.DeclaringMmd == this && f.SuperField == null) { SetNewMetadataClass(true); } // recursively call this method on nested fields f.Repository = repository; if (f is MetaMetadataNestedField) { MetaMetadataNestedField f1 = (MetaMetadataNestedField)f; f1.InheritMetaMetadata(inheritanceHandler); if (f1.IsNewMetadataClass()) { SetNewMetadataClass(true); } MetaMetadataNestedField f0 = (MetaMetadataNestedField)f.SuperField; if (f0 != null && f0.GetTypeName() != f1.GetTypeName()) { // inherited field w changing base type (polymorphic case) f1.InheritMetaMetadata(inheritanceHandler); MetaMetadata mmd0 = f0.TypeMmd; MetaMetadata mmd1 = f1.TypeMmd; if (mmd1.IsDerivedFrom(mmd0)) { SetNewMetadataClass(true); } else { throw new MetaMetadataException("incompatible types: " + mmd0 + " => " + mmd1); } } } } // clone fields only declared in inheritedStructure. // must clone them after recursively calling inheritMetaMetadata(), so that their nested // structures (which may be inherited too) can be cloned. if (inheritedStructure != null) { var inheritedStructSubfields = inheritedStructure.Kids.Values; foreach (MetaMetadataField field in inheritedStructSubfields) { string fieldName = field.Name; MetaMetadataField fieldLocal; kids.TryGetValue(fieldName, out fieldLocal); if (fieldLocal == null) { // MetaMetadataField clonedField = (MetaMetadataField) field.clone(); // clonedField.setParent(this); // this.getChildMetaMetadata().put(fieldName, clonedField); kids.Put(fieldName, field); } } } }
protected virtual MetaMetadata FindOrGenerateInheritedMetaMetadata(MetaMetadataRepository repository, InheritanceHandler inheritanceHandler) { MetaMetadata inheritedMmd = this.TypeMmd; if (inheritedMmd == null) { MmdScope mmdScope = this.Scope; String inheritedMmdName = Type ?? Name; if (ExtendsAttribute != null) { // determine new type name if (inheritedMmdName == null) { throw new MetaMetadataException("attribute 'name' must be specified: " + this); } if (inheritanceHandler.ResolveMmdName(inheritedMmdName) != null) { // currently we don't encourage re-using existing name. however, in the future, when package names are available, we can change this. throw new MetaMetadataException("meta-metadata '" + inheritedMmdName + "' already exists! please use another name to prevent name collision. hint: use 'tag' to change the tag if needed."); } // determine from which meta-metadata to inherit inheritedMmd = inheritanceHandler.ResolveMmdName(ExtendsAttribute); if (ExtendsAttribute == null || inheritedMmd == null) { throw new MetaMetadataException("super type not specified or recognized: " + this + ", super type name: " + ExtendsAttribute); } // generate inline mmds and put it into current scope MetaMetadata generatedMmd = this.GenerateMetaMetadata(inheritedMmdName, inheritedMmd); mmdScope.Put(inheritedMmdName, generatedMmd); mmdScope.Put(generatedMmd.Name, generatedMmd); // recursively do inheritance on generated mmd generatedMmd.InheritMetaMetadata(null); // this will set generateClassDescriptor to true if necessary MakeThisFieldUseMmd(inheritedMmdName, generatedMmd); return(generatedMmd); } else { // use type / extends if (inheritedMmdName == null) { throw new MetaMetadataException("no type / extends defined for " + this + " (note that due to a limitation explicit child_scalar_type is needed for scalar collection fields, even if it has been declared in super field)."); } NameType[] nameType = new NameType[1]; inheritedMmd = inheritanceHandler.ResolveMmdName(inheritedMmdName, nameType); if (inheritedMmd == null) { throw new MetaMetadataException("meta-metadata not found: " + inheritedMmdName + " (if you want to define new types inline, you need to specify extends/child_extends)."); } if (!inheritedMmdName.Equals(inheritedMmd.Name) && nameType[0] == NameType.MMD) { // could be inline mmd this.MakeThisFieldUseMmd(inheritedMmdName, inheritedMmd); } // process normal mmd / field Debug.WriteLine("setting " + this + ".inheritedMmd to " + inheritedMmd); TypeMmd = inheritedMmd; } } return(inheritedMmd); }
static MetaMetadataRepositoryInit() { SimplTypesScope.graphSwitch = SimplTypesScope.GRAPH_SWITCH.ON; MetaMetadataRepository.InitializeTypes(); }
public InheritanceHandler(MetaMetadata rootMmd) { this.rootMmd = rootMmd; this.repository = rootMmd.Repository; }