public void StoreConfig()
        {
            TermData T1 = new TermData(DTT1S.Value, DTT1E.Value, NuSFT1Grant.Value, NuSFT1Loan.Value,
                DTSFP1.Value, NUBT1.Value, DTBT1.Value);
            TermData T2 = new TermData(DTT2S.Value, DTT2E.Value, NuSFT2Grant.Value, NuSFT2Loan.Value,
                DTSFP2.Value, NUBT2.Value, DTBT2.Value);
            TermData T3 = new TermData(DTT3S.Value, DTT3E.Value, NuSFT3Grant.Value, NuSFT3Loan.Value,
                DTSFP3.Value, NUBT3.Value, DTBT3.Value);

            YearInfo YI = new YearInfo(CBYII.Checked, T1 , T2, T3);
            MessageBox.Show(RC.YearInfo.Count.ToString());
            //int year = (int) NUYear.Value - 1;  //0 based index
            //MessageBox.Show(year.ToString() + "is year\n" + YearRecords.Count.ToString());
            //if ( YearRecords.Count > 0 && year <= YearRecords.Count)
            //    // List populated && Year in existing range
            //{
            //    //if (YearRecords.Count >= year)
            //    YearRecords[year] = YI;
            //}
            // else
            YearRecords.Add(YI);   //PoulateEmpty | append

            RC = new Configuration(NUYear.Value, YearRecords);
            XmlSerializer XSR = new XmlSerializer(typeof(Configuration));
            FileStream ConfigStream = new FileStream("Finances.rc", FileMode.Create);
            try
            {
                XSR.Serialize(ConfigStream, RC);
            }
            catch (Exception Ex)
            {
                MessageBox.Show(Ex.GetBaseException().ToString());
            }
            ConfigStream.Close();
            LoadConfig();
            MessageBox.Show("Configurations recorded");
            MessageBox.Show(YearRecords.Count.ToString());
        }
Ejemplo n.º 2
0
            public virtual void _run()
            {
                for (int iter = 0; iter < NUM_TEST_ITER; iter++)
                {
                    FieldData field     = Fields[Random.Next(Fields.Length)];
                    TermsEnum termsEnum = TermsDict.GetTerms(field.FieldInfo.Name).GetIterator(null);
#pragma warning disable 612, 618
                    if (Si.Codec is Lucene3xCodec)
#pragma warning restore 612, 618
                    {
                        // code below expects unicode sort order
                        continue;
                    }

                    int upto = 0;
                    // Test straight enum of the terms:
                    while (true)
                    {
                        BytesRef term = termsEnum.Next();
                        if (term == null)
                        {
                            break;
                        }
                        BytesRef expected = new BytesRef(field.Terms[upto++].Text2);
                        Assert.IsTrue(expected.BytesEquals(term), "expected=" + expected + " vs actual " + term);
                    }
                    Assert.AreEqual(upto, field.Terms.Length);

                    // Test random seek:
                    TermData             term2  = field.Terms[Random.Next(field.Terms.Length)];
                    TermsEnum.SeekStatus status = termsEnum.SeekCeil(new BytesRef(term2.Text2));
                    Assert.AreEqual(status, TermsEnum.SeekStatus.FOUND);
                    Assert.AreEqual(term2.Docs.Length, termsEnum.DocFreq);
                    if (field.OmitTF)
                    {
                        this.VerifyDocs(term2.Docs, term2.Positions, TestUtil.Docs(Random, termsEnum, null, null, DocsFlags.NONE), false);
                    }
                    else
                    {
                        this.VerifyDocs(term2.Docs, term2.Positions, termsEnum.DocsAndPositions(null, null), true);
                    }

                    // Test random seek by ord:
                    int idx = Random.Next(field.Terms.Length);
                    term2 = field.Terms[idx];
                    bool success = false;
                    try
                    {
                        termsEnum.SeekExact(idx);
                        success = true;
                    }
#pragma warning disable 168
                    catch (System.NotSupportedException uoe)
#pragma warning restore 168
                    {
                        // ok -- skip it
                    }
                    if (success)
                    {
                        Assert.AreEqual(status, TermsEnum.SeekStatus.FOUND);
                        Assert.IsTrue(termsEnum.Term.BytesEquals(new BytesRef(term2.Text2)));
                        Assert.AreEqual(term2.Docs.Length, termsEnum.DocFreq);
                        if (field.OmitTF)
                        {
                            this.VerifyDocs(term2.Docs, term2.Positions, TestUtil.Docs(Random, termsEnum, null, null, DocsFlags.NONE), false);
                        }
                        else
                        {
                            this.VerifyDocs(term2.Docs, term2.Positions, termsEnum.DocsAndPositions(null, null), true);
                        }
                    }

                    // Test seek to non-existent terms:
                    if (VERBOSE)
                    {
                        Console.WriteLine("TEST: seek non-exist terms");
                    }
                    for (int i = 0; i < 100; i++)
                    {
                        string text2 = TestUtil.RandomUnicodeString(Random) + ".";
                        status = termsEnum.SeekCeil(new BytesRef(text2));
                        Assert.IsTrue(status == TermsEnum.SeekStatus.NOT_FOUND || status == TermsEnum.SeekStatus.END);
                    }

                    // Seek to each term, backwards:
                    if (VERBOSE)
                    {
                        Console.WriteLine("TEST: seek terms backwards");
                    }
                    for (int i = field.Terms.Length - 1; i >= 0; i--)
                    {
                        Assert.AreEqual(TermsEnum.SeekStatus.FOUND, termsEnum.SeekCeil(new BytesRef(field.Terms[i].Text2)), Thread.CurrentThread.Name + ": field=" + field.FieldInfo.Name + " term=" + field.Terms[i].Text2);
                        Assert.AreEqual(field.Terms[i].Docs.Length, termsEnum.DocFreq);
                    }

                    // Seek to each term by ord, backwards
                    for (int i = field.Terms.Length - 1; i >= 0; i--)
                    {
                        try
                        {
                            termsEnum.SeekExact(i);
                            Assert.AreEqual(field.Terms[i].Docs.Length, termsEnum.DocFreq);
                            Assert.IsTrue(termsEnum.Term.BytesEquals(new BytesRef(field.Terms[i].Text2)));
                        }
#pragma warning disable 168
                        catch (System.NotSupportedException uoe)
#pragma warning restore 168
                        {
                        }
                    }

                    // Seek to non-existent empty-string term
                    status = termsEnum.SeekCeil(new BytesRef(""));
                    Assert.IsNotNull(status);
                    //Assert.AreEqual(TermsEnum.SeekStatus.NOT_FOUND, status);

                    // Make sure we're now pointing to first term
                    Assert.IsTrue(termsEnum.Term.BytesEquals(new BytesRef(field.Terms[0].Text2)));

                    // Test docs enum
                    termsEnum.SeekCeil(new BytesRef(""));
                    upto = 0;
                    do
                    {
                        term2 = field.Terms[upto];
                        if (Random.Next(3) == 1)
                        {
                            DocsEnum             docs;
                            DocsEnum             docsAndFreqs;
                            DocsAndPositionsEnum postings;
                            if (!field.OmitTF)
                            {
                                postings = termsEnum.DocsAndPositions(null, null);
                                if (postings != null)
                                {
                                    docs = docsAndFreqs = postings;
                                }
                                else
                                {
                                    docs = docsAndFreqs = TestUtil.Docs(Random, termsEnum, null, null, DocsFlags.FREQS);
                                }
                            }
                            else
                            {
                                postings     = null;
                                docsAndFreqs = null;
                                docs         = TestUtil.Docs(Random, termsEnum, null, null, DocsFlags.NONE);
                            }
                            Assert.IsNotNull(docs);
                            int  upto2 = -1;
                            bool ended = false;
                            while (upto2 < term2.Docs.Length - 1)
                            {
                                // Maybe skip:
                                int left = term2.Docs.Length - upto2;
                                int doc;
                                if (Random.Next(3) == 1 && left >= 1)
                                {
                                    int inc = 1 + Random.Next(left - 1);
                                    upto2 += inc;
                                    if (Random.Next(2) == 1)
                                    {
                                        doc = docs.Advance(term2.Docs[upto2]);
                                        Assert.AreEqual(term2.Docs[upto2], doc);
                                    }
                                    else
                                    {
                                        doc = docs.Advance(1 + term2.Docs[upto2]);
                                        if (doc == DocIdSetIterator.NO_MORE_DOCS)
                                        {
                                            // skipped past last doc
                                            Debug.Assert(upto2 == term2.Docs.Length - 1);
                                            ended = true;
                                            break;
                                        }
                                        else
                                        {
                                            // skipped to next doc
                                            Debug.Assert(upto2 < term2.Docs.Length - 1);
                                            if (doc >= term2.Docs[1 + upto2])
                                            {
                                                upto2++;
                                            }
                                        }
                                    }
                                }
                                else
                                {
                                    doc = docs.NextDoc();
                                    Assert.IsTrue(doc != -1);
                                    upto2++;
                                }
                                Assert.AreEqual(term2.Docs[upto2], doc);
                                if (!field.OmitTF)
                                {
                                    Assert.AreEqual(term2.Positions[upto2].Length, postings.Freq);
                                    if (Random.Next(2) == 1)
                                    {
                                        this.VerifyPositions(term2.Positions[upto2], postings);
                                    }
                                }
                            }

                            if (!ended)
                            {
                                Assert.AreEqual(DocIdSetIterator.NO_MORE_DOCS, docs.NextDoc());
                            }
                        }
                        upto++;
                    } while (termsEnum.Next() != null);

                    Assert.AreEqual(upto, field.Terms.Length);
                }
            }
Ejemplo n.º 3
0
        public virtual void TestFixedPostings()
        {
            const int NUM_TERMS = 100;

            TermData[] terms = new TermData[NUM_TERMS];
            for (int i = 0; i < NUM_TERMS; i++)
            {
                int[]  docs = new int[] { i };
                string text = Convert.ToString(i);
                terms[i] = new TermData(this, text, docs, null);
            }

            FieldInfos.Builder builder = new FieldInfos.Builder();

            FieldData field = new FieldData(this, "field", builder, terms, true, false);

            FieldData[] fields     = new FieldData[] { field };
            FieldInfos  fieldInfos = builder.Finish();

            // LUCENENET specific - BUG: we must wrap this in a using block in case anything in the below loop throws
            using (Directory dir = NewDirectory())
            {
                this.Write(fieldInfos, dir, fields, true);
                Codec       codec = Codec.Default;
                SegmentInfo si    = new SegmentInfo(dir, Constants.LUCENE_MAIN_VERSION, SEGMENT, 10000, false, codec, null);

                // LUCENENET specific - BUG: we must wrap this in a using block in case anything in the below loop throws
                using (FieldsProducer reader = codec.PostingsFormat.FieldsProducer(new SegmentReadState(dir, si, fieldInfos, NewIOContext(Random), DirectoryReader.DEFAULT_TERMS_INDEX_DIVISOR)))
                {
                    IEnumerator <string> fieldsEnum = reader.GetEnumerator();
                    fieldsEnum.MoveNext();
                    string fieldName = fieldsEnum.Current;
                    Assert.IsNotNull(fieldName);
                    Terms terms2 = reader.GetTerms(fieldName);
                    Assert.IsNotNull(terms2);

                    TermsEnum termsEnum = terms2.GetIterator(null);

                    DocsEnum docsEnum = null;
                    for (int i = 0; i < NUM_TERMS; i++)
                    {
                        BytesRef term = termsEnum.Next();
                        Assert.IsNotNull(term);
                        Assert.AreEqual(terms[i].Text2, term.Utf8ToString());

                        // do this twice to stress test the codec's reuse, ie,
                        // make sure it properly fully resets (rewinds) its
                        // internal state:
                        for (int iter = 0; iter < 2; iter++)
                        {
                            docsEnum = TestUtil.Docs(Random, termsEnum, null, docsEnum, DocsFlags.NONE);
                            Assert.AreEqual(terms[i].Docs[0], docsEnum.NextDoc());
                            Assert.AreEqual(DocIdSetIterator.NO_MORE_DOCS, docsEnum.NextDoc());
                        }
                    }
                    Assert.IsNull(termsEnum.Next());

                    for (int i = 0; i < NUM_TERMS; i++)
                    {
                        Assert.AreEqual(termsEnum.SeekCeil(new BytesRef(terms[i].Text2)), TermsEnum.SeekStatus.FOUND);
                    }

                    Assert.IsFalse(fieldsEnum.MoveNext());
                }
            }
        }
Ejemplo n.º 4
0
        internal virtual TermData[] MakeRandomTerms(bool omitTF, bool storePayloads)
        {
            int numTerms = 1 + Random.Next(NUM_TERMS_RAND);

            //final int numTerms = 2;
            TermData[] terms = new TermData[numTerms];

            ISet <string> termsSeen = new JCG.HashSet <string>();

            for (int i = 0; i < numTerms; i++)
            {
                // Make term text
                string text2;
                while (true)
                {
                    text2 = TestUtil.RandomUnicodeString(Random);
                    if (!termsSeen.Contains(text2) && !text2.EndsWith(".", StringComparison.Ordinal))
                    {
                        termsSeen.Add(text2);
                        break;
                    }
                }

                int              docFreq = 1 + Random.Next(DOC_FREQ_RAND);
                int[]            docs    = new int[docFreq];
                PositionData[][] positions;

                if (!omitTF)
                {
                    positions = new PositionData[docFreq][];
                }
                else
                {
                    positions = null;
                }

                int docID = 0;
                for (int j = 0; j < docFreq; j++)
                {
                    docID  += TestUtil.NextInt32(Random, 1, 10);
                    docs[j] = docID;

                    if (!omitTF)
                    {
                        int termFreq = 1 + Random.Next(TERM_DOC_FREQ_RAND);
                        positions[j] = new PositionData[termFreq];
                        int position = 0;
                        for (int k = 0; k < termFreq; k++)
                        {
                            position += TestUtil.NextInt32(Random, 1, 10);

                            BytesRef payload;
                            if (storePayloads && Random.Next(4) == 0)
                            {
                                var bytes = new byte[1 + Random.Next(5)];
                                for (int l = 0; l < bytes.Length; l++)
                                {
                                    bytes[l] = (byte)Random.Next(255);
                                }
                                payload = new BytesRef(bytes);
                            }
                            else
                            {
                                payload = null;
                            }

                            positions[j][k] = new PositionData(this, position, payload);
                        }
                    }
                }

                terms[i] = new TermData(this, text2, docs, positions);
            }

            return(terms);
        }
Ejemplo n.º 5
0
 private static bool StatsEqual(TermData t1, TermData t2)
 {
     return(t1.docFreq == t2.docFreq && t1.totalTermFreq == t2.totalTermFreq);
 }
Ejemplo n.º 6
0
 public override string OutputToString(TermData data)
 {
     return(data.ToString());
 }
Ejemplo n.º 7
0
 internal static bool StatsEqual(TermData t1, TermData t2)
 {
     return(t1.DOC_FREQ == t2.DOC_FREQ && t1.TOTAL_TERM_FREQ == t2.TOTAL_TERM_FREQ);
 }
 public YearInfo(bool YearInIndustry, TermData T1, TermData T2, TermData T3)
 {
     this.YearInIndustry = YearInIndustry;
     this.T1 = T1;
     this.T2 = T2;
     this.T3 = T3;
 }
        /// <summary>
        /// Main entry method for transforming terms
        /// </summary>
        public TermData Transform(TermData inputSourceTerm)
        {
            //Design:
            // This will have two modes:
            // Default mode to work out the terms from source to destination based on identical IDs or Term Paths
            // Mapping file to override default mode for specifically mapping a source term to designation term

            //Scenarios:
            // Term Ids or Term Names
            // Source or Target Term ID/Name may not be found

            // Default Mode
            if (!this.skipTermStoreMapping && !_baseTransformationInformation.IsCrossFarmTransformation)
            {
                var resolvedInputMapping = ResolveTermInCache(this._sourceContext, inputSourceTerm.TermGuid);

                if (resolvedInputMapping.IsTermResolved)
                {
                    //Check if the source term ID exists in target then map.
                    var resolvedInputMappingInTarget = ResolveTermInCache(this._targetContext, inputSourceTerm.TermGuid);
                    if (resolvedInputMappingInTarget.IsTermResolved && !resolvedInputMapping.IsSourceTerm)
                    {
                        inputSourceTerm.IsTermResolved = true;                                   //Happy that term ID is the same as source
                        inputSourceTerm.TermLabel      = resolvedInputMappingInTarget.TermLabel; //Just in case the ids are the same and labels are not
                        return(inputSourceTerm);
                    }

                    //Check if the term labels are the same, ids maybe different - in this scenario, validate if the term paths are the same.
                    //if so, then auto-map.
                    resolvedInputMappingInTarget = ResolveTermInCache(this._targetContext, resolvedInputMapping.TermPath);
                    if (resolvedInputMappingInTarget.IsTermResolved && !resolvedInputMapping.IsSourceTerm)
                    {
                        inputSourceTerm.IsTermResolved = true;                                  //Happy that term ID is the same as source
                        inputSourceTerm.TermGuid       = resolvedInputMappingInTarget.TermGuid; //Just in case the ids are the same and labels are not
                        return(inputSourceTerm);
                    }
                }
            }

            // Mapping Mode
            if (termMappings != null)
            {
                var resolvedInputMapping = ResolveTermInCache(this._sourceContext, inputSourceTerm.TermGuid);

                //Check Source Mappings
                foreach (var mapping in termMappings)
                {
                    // Simple Check, if the delimiter is | lets check for that
                    if (mapping.SourceTerm.Contains("|"))
                    {
                        //Term Path
                        // If found validate against the term cache
                        if (resolvedInputMapping.TermPath == mapping.SourceTerm)
                        {
                            var resolvedTargetMapping = ResolveTermInCache(this._targetContext, mapping.TargetTerm);
                            if (resolvedTargetMapping != default)
                            {
                                return(resolvedTargetMapping);
                            }
                            else
                            {
                                //Log Failure in resolving to target mapping
                                LogWarning(string.Format(LogStrings.Warning_TermMappingFailedResolveTarget, mapping.TargetTerm), LogStrings.Heading_TermMapping);
                            }
                        }
                    }
                    else
                    {
                        //Guid
                        if (Guid.TryParse(mapping.SourceTerm, out Guid mappingSourceTermId))
                        {
                            //Found
                            if (resolvedInputMapping.TermGuid == mappingSourceTermId)
                            {
                                if (Guid.TryParse(mapping.TargetTerm, out Guid mappingTargetTermId))
                                {
                                    var resolvedTargetMapping = ResolveTermInCache(this._targetContext, mappingTargetTermId);
                                    if (resolvedTargetMapping != default)
                                    {
                                        return(resolvedTargetMapping);
                                    }
                                    else
                                    {
                                        //Log Failure in resolving to target mapping
                                        LogWarning(string.Format(LogStrings.Warning_TermMappingFailedResolveTarget, mapping.TargetTerm), LogStrings.Heading_TermMapping);
                                    }
                                }
                                else
                                {
                                    var resolvedTargetMapping = ResolveTermInCache(this._targetContext, mapping.TargetTerm);
                                    if (resolvedTargetMapping != default)
                                    {
                                        return(resolvedTargetMapping);
                                    }
                                    else
                                    {
                                        //Log Failure in resolving to target mapping
                                        LogWarning(string.Format(LogStrings.Warning_TermMappingFailedResolveTarget, mapping.TargetTerm), LogStrings.Heading_TermMapping);
                                    }
                                }
                            }
                        }
                        else
                        {
                            // Failure in parsing the Term ID
                        }
                    }
                }

                //Log Failure in mapping
                LogWarning(string.Format(LogStrings.Warning_TermMappingFailedMapping, inputSourceTerm.TermGuid, inputSourceTerm.TermLabel), LogStrings.Heading_TermMapping);
            }


            return(inputSourceTerm); //Pass-Through
        }
Ejemplo n.º 10
0
 private bool IsTermUpdated(Term dbTerm, TermData termData)
 {
     return(dbTerm.Text != termData.Text ||
            dbTerm.Position != termData.Position ||
            dbTerm.TermCategory.Name != termData.TermCategoryName);
 }
Ejemplo n.º 11
0
    public static void ProcessAllPrefabs()
    {
        int languageIndex = GetEnglishLanguageIndex();

        if (languageIndex == -1)
        {
            return;
        }

        List <GameObject> allPrefabs = PrefabLoader.LoadAllPrefabs("Assets/Prefabs");

        foreach (GameObject prefab in allPrefabs)
        {
            MonoBehaviour[] monoBehaviours = prefab.GetComponentsInChildren <MonoBehaviour>();
            foreach (MonoBehaviour mb in monoBehaviours)
            {
                if (mb == null)
                {
                    Debug.Log(prefab.name + " referencing dead component", prefab);
                    continue;
                }

                string chunks = string.Empty;

                SerializedObject   mbSO     = new SerializedObject(mb);
                SerializedProperty propIter = mbSO.GetIterator();
                propIter.Next(true);

                bool anyChanged = false;

                while (propIter.Next(true))
                {
                    if (propIter.type == typeof(DialogueChunk).ToString() && propIter.isArray)
                    {
                        for (int j = 0; j < propIter.arraySize; j++)
                        {
                            SerializedProperty chunkProp        = propIter.GetArrayElementAtIndex(j);
                            SerializedProperty dialogueTermProp = chunkProp.FindPropertyRelative("dialogueTerm");

                            string displayPropPath = chunkProp.propertyPath
                                                     .Replace("_", "")
                                                     .Replace(".Array.data", "")
                                                     .Replace("[", "-")
                                                     .Replace("]", "");

                            displayPropPath = char.ToUpper(displayPropPath[0]) + displayPropPath.Substring(1);

                            string   termName = string.Format("Dialogue/{0}_{1}", prefab.name, displayPropPath);
                            TermData termData = LocalizationManager.GetTermData(termName);
                            if (termData == null)
                            {
                                termData = LocalizationManager.Sources[0].AddTerm(termName);
                                chunks  += termName + "\n";
                            }

                            string prevTranslation = termData.GetTranslation(languageIndex);
                            string newTranslation  = chunkProp.FindPropertyRelative("dialogue").stringValue;

                            if (prevTranslation == string.Empty ||
                                newTranslation != prevTranslation ||
                                dialogueTermProp.stringValue != termName)
                            {
                                termData.SetTranslation(languageIndex, newTranslation);
                                dialogueTermProp.stringValue = termName;
                                anyChanged = true;
                            }
                        }
                    }
                }

                if (anyChanged)
                {
                    mbSO.ApplyModifiedProperties();
                    EditorUtility.SetDirty(LocalizationManager.Sources[0]);
                }

                if (chunks != string.Empty)
                {
                    Debug.Log(prefab.name + ":\n" + chunks);
                }
            }
        }

        AssetDatabase.SaveAssets();
    }
Ejemplo n.º 12
0
    public static void FixBrokenTermPopups()
    {
        // Iterate over all prefabs, find TermPopup attributed properties, check if valid term, if not try to fix by adding category

        int languageIndex = GetEnglishLanguageIndex();

        if (languageIndex == -1)
        {
            return;
        }

        string fixedProperties = string.Empty;

        List <GameObject> allPrefabs = PrefabLoader.LoadAllPrefabs("Assets/Prefabs");

        foreach (GameObject prefab in allPrefabs)
        {
            MonoBehaviour[] monoBehaviours = prefab.GetComponentsInChildren <MonoBehaviour>();
            foreach (MonoBehaviour mb in monoBehaviours)
            {
                if (mb == null)
                {
                    Debug.Log(prefab.name + " referencing dead component", prefab);
                    continue;
                }

                SerializedObject mbSO = new SerializedObject(mb);

                bool anyChanged = false;

                FieldInfo[] fieldInfos = mb.GetType().GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
                foreach (FieldInfo fieldInfo in fieldInfos)
                {
                    object[] attributes = fieldInfo.GetCustomAttributes(true);
                    foreach (object attribute in attributes)
                    {
                        TermsPopup termsPopup = attribute as TermsPopup;
                        if (termsPopup != null)
                        {
                            SerializedProperty termProp = mbSO.FindProperty(fieldInfo.Name);
                            string             termName = termProp.stringValue;

                            TermData termData = LocalizationManager.GetTermData(termName);
                            if (termData == null)
                            {
                                foreach (var kvp in LocalizationManager.Sources[0].mDictionary)
                                {
                                    if (kvp.Value.IsTerm(termName, true))
                                    {
                                        termData             = kvp.Value;
                                        termProp.stringValue = termData.Term;

                                        fixedProperties += termProp.propertyPath + "\n";
                                        anyChanged       = true;
                                        break;
                                    }
                                }

                                break;
                            }
                        }
                    }
                }

                if (anyChanged)
                {
                    mbSO.ApplyModifiedProperties();
                }
            }
        }

        if (fixedProperties != string.Empty)
        {
            Debug.Log("Fixed Properties:\n" + fixedProperties);
            AssetDatabase.SaveAssets();
        }
    }