Example #1
0
 public static List<CreaDicMyspell> GeneraCreadors(ItemDic itemMostra,
     Dictionary<string, List<ReglaMyspell>> vellANou, Regles regles)
 {
     List<CreaDicMyspell> creadors = new List<CreaDicMyspell>();
     // Feim la llista de regles que han d'aparèixer a tots els creadors
     List<string> reglesComunes = new List<string>();
     foreach (string idRegla in itemMostra.LlistaFlags)
     {
         if (vellANou[idRegla].Count == 0) throw new Exception("Regla sense equivalència: " + idRegla);
         if (vellANou[idRegla].Count == 1 && vellANou[idRegla][0].EsRegla)
             reglesComunes.Add(vellANou[idRegla][0].Id);
     }
     // Cream regles per als altres flags
     foreach (string idRegla in itemMostra.LlistaFlags)
     {
         foreach (ReglaMyspell regla in vellANou[idRegla])
         {
             if (regla.EsRegla)
             {
                 CreaDicMyspellRegla creador = new CreaDicMyspellRegla(regles);
                 creador.MesFlags(reglesComunes);
                 creador.MesFlags(regla.Id);
                 creador.ConverteixArrel = regla.Afinador;
                 foreach (Regla contraria in regla.AfixosContraris)
                     foreach (ReglaMyspell nova in vellANou[contraria.Id])
                         creador.MesFlags(nova.Id);
                 creadors.Add(creador);
             }
             else
             {
                 foreach (CasRegla cas in regla.Casos)
                 {
                     CreaDicMyspellCas creador = new CreaDicMyspellCas(cas, regles);
                     creador.MesFlags(reglesComunes);
                     creador.ConverteixArrel = regla.Afinador;
                     foreach (Regla igual in regla.AfixosIguals)
                         foreach (ReglaMyspell nova in vellANou[igual.Id])
                             creador.MesFlags(nova.Id); ;
                     foreach (Regla contraria in regla.AfixosContraris)
                         foreach (ReglaMyspell nova in vellANou[contraria.Id])
                             creador.MesFlags(nova.Id); ;
                     creadors.Add(creador);
                 }
             }
         }
     }
     // Si no hem afegit cap creador, tornam el vell
     if (creadors.Count == 0)
     {
         CreaDicMyspellRegla creador = new CreaDicMyspellRegla(regles);
         creador.MesFlags(reglesComunes);
         creadors.Add(creador);
     }
     //
     return creadors;
 }
Example #2
0
 public override ItemDic Converteix(ItemDic itemVell)
 {
     string arrel = Arrel(itemVell);
     if (!cas.EsAplicable(arrel))
         return null;
     List<Mot> mots = new List<Mot>();
     if (cas.Genera(arrel, ref mots, null, regles, Marques.totes, true) != 1) throw new Exception("S'esperava un mot");
     ItemDic nou = new ItemDic(mots[0].Forma);
     foreach (string idRegla in nousFlags)
         if (regles.Llista[idRegla].EsAplicable(nou.Arrel))
             nou.MesFlags(idRegla);
     return nou;
 }
Example #3
0
 public override ItemDic Converteix(ItemDic itemVell)
 {
     string arrel = Arrel(itemVell);
     ItemDic nou = new ItemDic(arrel);
     foreach (string idRegla in nousFlags)
         if (regles.Llista[idRegla].EsAplicable(arrel))
             nou.MesFlags(idRegla);
     return nou;
 }
Example #4
0
 /// <summary>
 /// Crea un ItemDic equivalent a itemVell.
 /// </summary>
 /// <param name="itemVell">L'ítem que volem convertir.</param>
 /// <returns>Un nou ítem vell.</returns>
 public abstract ItemDic Converteix(ItemDic itemVell);
Example #5
0
 protected string Arrel(ItemDic itemVell)
 {
     string arrel = itemVell.Arrel;
     if (converteixArrel != null)
         arrel = converteixArrel.ProcessaArrel(arrel);
     return arrel;
 }
Example #6
0
 /// <summary>
 /// Diu si els flags d'aquest ítem són compatibles amb els d'un altre.
 /// Són compatibles si:
 /// - Són iguals
 /// </summary>
 public bool FlagsCompatibles(ItemDic altre, Regles regles)
 {
     return regles.ReglesCompatibles(FlagsComLletres, altre.FlagsComLletres);
 }
Example #7
0
 /// <summary>
 /// Afegeix els flags d'un altre ítem.
 /// </summary>
 public void MesFlags(ItemDic altre)
 {
     for (int i = 0; i < flags.Length; i++)
         this.flags[i] |= altre.flags[i];
     flagsComLletres = null;
 }
Example #8
0
 /// <summary>
 /// Torna una llista d'ItemDic aplanada.
 /// Els ítems de la llista nova només contenen flags per a regles amb EsSufix = false.
 /// </summary>
 /// <param name="items">La llista d'ítems que volem aplanar.</param>
 /// <param name="regles">La llista de regles que emprarem.</param>
 /// <param name="filtre">Només es generen mots que tenen marques contingudes en aquest filtre.</param>
 /// <returns>La llista aplanada.</returns>
 public static List<ItemDic> Aplana(List<ItemDic> items, Regles regles, Marques filtre)
 {
     // PERFER: No desplegar els futurs i els condicionals, ja que són sempre regulars (?)
     List<ItemDic> llista = new List<ItemDic>();
     foreach (ItemDic item in items)
     {
         string arrel = item.Arrel;
         List<Regla> aff = null;
         List<string> noAff = new List<string>();
         foreach (string idRegla in item.LlistaFlags)
         {
             Regla regla = regles.Llista[idRegla];
             if (regla.EsAfix)
             {
                 if (aff == null)
                     aff = new List<Regla>();
                 aff.Add(regla);
             }
             else
             {
                 noAff.Add(idRegla);
             }
         }
         if (aff == null)
         {
             // PER_FER: mirar si no hem de posar totes les regles de noaff
             llista.Add(item);
         }
         else // (aff != null)
         {
             ItemDic nou = null;
             // Afegim l'arrel nua
             nou = new ItemDic(arrel, noAff.ToArray());
             nou.MesMorfoGram(item.mgComuna, item.mgArrel);
             llista.Add(nou);
             // Afegim els mots generats per les regles d'aff
             foreach (Regla regla in aff)
             {
                 List<Mot> mots = new List<Mot>();
                 foreach (CasRegla cas in regla.Casos)
                 {
                     mots.Clear();
                     int generats = cas.Genera(arrel, ref mots, item.mgComuna, regles, filtre, true);
                     if (generats == 0)
                         continue;
                     if (generats > 1) throw new Exception("S'esperava un sol mot per al cas");
                     Mot mot = mots[0];
                     nou = new ItemDic(mot.Forma);
                     if (regla.EsCombinable)
                         foreach (string id in noAff)
                         {
                             Regla reglaNoAff = regles.Llista[id];
                             if (reglaNoAff.EsCombinable && reglaNoAff.EsAplicable(nou.Arrel))
                                 nou.MesFlags(id);
                         }
                     if (cas.MesRegles != null)
                     {
                         foreach (string id in cas.MesRegles)
                         {
                             Regla reglaExtra = regles.Llista[id];
                             if (reglaExtra.EsAplicable(nou.Arrel))
                                 nou.MesFlags(id);
                         }
                     }
                     nou.MesMorfoGram(item.mgComuna, mot.Info);
                     llista.Add(nou);
                 }
             }
         }
     }
     return llista;
 }
Example #9
0
 /// <summary>
 /// Compacta una llista d'ítems.
 /// Torna una llista amb la longitud mínima i ordenada.
 /// Uneix els ítems que tenguin la mateixa arrel i siguin compatibles.
 /// El procés d'unió es repeteix fins que es pugui.
 /// La informació morfològica i gramatical dels ítems es perd.
 /// </summary>
 /// <param name="llista">La llista d'entrada, segurament amb repeticions i ítems que es poden unir.</param>
 /// <param name="regles">Les regles per interpretar els flags dels ítems.</param>
 /// <param name="comparador">Una funció per ordenar la llista resultant.</param>
 /// <returns>Una llista compactada.</returns>
 public static List<ItemDic> CompactaLlista(List<ItemDic> llista, Regles regles, Comparison<string> comparador)
 {
     Dictionary<string, List<ItemDic>> unics = new Dictionary<string, List<ItemDic>>();
     foreach (ItemDic item in llista)
     {
         if (!unics.ContainsKey(item.Arrel))
             unics.Add(item.Arrel, new List<ItemDic>());
         ItemDic nou = new ItemDic(item.Arrel);
         nou.MesFlags(item);
         List<ItemDic> grup = unics[item.Arrel];
         grup.Add(nou);
         while (grup.Count > 1)
         {
             bool canvis = false;
             for(int i=0; i<grup.Count - 1; i++)
             {
                 for (int j = i + 1; j < grup.Count; j++)
                 {
                     ItemDic item1 = grup[i];
                     ItemDic item2 = grup[j];
                     if (item1.FlagsCompatibles(item2, regles))
                     {
                         item1.MesFlags(item2);
                         grup.Remove(item2);
                         canvis = true;
                         break;
                     }
                 }
                 if (canvis)
                     break;
             }
             break;
         }
     }
     List<ItemDic> llistaNova = new List<ItemDic>(unics.Count * 2);
     foreach (List<ItemDic> grup in unics.Values)
         llistaNova.AddRange(grup);
     llistaNova.Sort(delegate(ItemDic item1, ItemDic item2)
     {
         int cmp = comparador(item1.Arrel, item2.Arrel);
         return (cmp != 0) ? cmp : string.Compare(item1.FlagsComLletres, item2.FlagsComLletres);
     });
     return llistaNova;
 }
 public override void Genera(Dictionary<string, string> dades, Dictionary<string, string> excepcions, Marques filtre, List<ItemDic> items)
 {
     ItemDic item = new ItemDic(forma);
     if (admetD)
         item.MesFlags("Y");
     if (admetL)
         item.MesFlags("V");
     items.Add(item);
 }
Example #11
0
 private void test_01(GrupTest arrel)
 {
     GrupTest grup = arrel.NouGrup("ItemDic");
     ItemDic id1 = null, id2 = null;
     grup.NouTest("Crea amb arrel i flags (string)", delegate(RTest resultat)
     {
         id2 = new ItemDic("xyz", "C", "Z", "z");
         resultat.Esperat("xyz/CZz", id2.ToString());
     });
     grup.NouTest("Flags admissibles", delegate(RTest resultat)
     {
         try
         {
             ItemDic id = new ItemDic("xyz", "ab");
             resultat.Error("No s'ha impedit l'ús d'un flag il·legal");
         }
         catch (ItemDicException)
         {
             resultat.Nota("S'ha impedit l'ús d'un flag il·legal");
         }
     });
     grup.NouTest("Crea amb arrel i flags (string)", delegate(RTest resultat)
     {
         id1 = new ItemDic("xyz", "C");
         resultat.Esperat("xyz/C", id1.ToString());
         id1.MesFlags("D");
         resultat.Esperat("xyz/CD", id1.ToString());
         id2 = new ItemDic("xyz", "E");
         id1.MesFlags(id2);
         resultat.Esperat("xyz/CDE", id1.ToString());
     });
 }
 public override void Genera(Dictionary<string, string> dades, Dictionary<string, string> excepcions, Marques filtre, List<ItemDic> items)
 {
     ItemDic item = new ItemDic(forma, flags);
     if (mg != null)
         item.MesMorfoGram(mg, mg);
     items.Add(item);
 }
 public override void Genera(Dictionary<string, string> dades, Dictionary<string, string> excepcions, Marques filtre, List<ItemDic> items)
 {
     string arrel0, arrel1;
     arrel0 = Arrel0(dades["arrel"], out arrel1);
     int numArrel = (mgComuna.Gen == MorfoGram.eGen.F) ? 1 : 0;
     ItemDic item = new ItemDic((numArrel == 1) ? arrel1 : arrel0, regla);
     item.MesMorfoGram(mgComuna, mgArrel);
     if (admetD)
         item.MesFlags("Y");
     if (admetL)
     {
         if (numArrel == 0)
             item.MesFlags("V");
         else
         {
             Paraula paraula = new Paraula(arrel1);
             if (paraula.PotApostrofar(true))
                 item.MesFlags("V");
         }
     }
     items.Add(item);
 }
 public override void Genera(Dictionary<string, string> dades, Dictionary<string, string> excepcions, Marques filtre, List<ItemDic> items)
 {
     ItemDic item = new ItemDic(dades["arrel"]);
     item.MesMorfoGram(mgComuna, null);
     if (admetD)
         item.MesFlags("Y");
     if (admetL)
         item.MesFlags("V");
     if (admetN)
         item.MesFlags("W");
     items.Add(item);
 }
 protected void AfegeixItem(List<ItemDic> llista, string arrel, MorfoGram mgComuna, MorfoGram mgArrel, 
     params string[] flags)
 {
     ItemDic item = llista.Find(delegate(ItemDic i) {
         return (i.Arrel == arrel) && MorfoGram.Unificables(i.mgComuna, mgComuna) && MorfoGram.Unificables(i.mgArrel, mgArrel);
     });
     if (item == null)
     {
         item = new ItemDic(arrel, flags);
         llista.Add(item);
     }
     else
         item.MesFlags(flags);
     item.MesMorfoGram(mgComuna, mgArrel);
 }
 private ItemDic MesUn(string arrel)
 {
     MorfoGram mg;
     SeparaArrelMG(arrel, out arrel, out mg);
     ItemDic item = null;
     if (mg.Temps == MorfoGram.eTemps.IMP)
     {
         Paraula pArrel = new Paraula(arrel);
         item = new ItemDic(arrel, pArrel.VocalFinal ? "D" : "C");
     }
     else if (mg.Temps == MorfoGram.eTemps.INF)
     {
         Paraula pInf = new Paraula(arrel);
         string flagFinal = pInf.VocalFinal ? "D" : "C";
         if (pInf.VocalInicial)
             item = new ItemDic(arrel, "Y", flagFinal);
         else
             item = new ItemDic(arrel, flagFinal);
     }
     else if (mg.Temps != MorfoGram.eTemps.NOTEMPS)
     {
         if (Paraula.TeVocalInicial(arrel))
             item = new ItemDic(arrel, "Z");
     }
     if (item == null)
         item = new ItemDic(arrel);
     item.MesMorfoGram(null, mg);
     return item;
 }