예제 #1
0
파일: Utilities.cs 프로젝트: Zhoner/Delphi
        static public DictBuilder dictBuilder()
        {
            if (dctBuilder == null)
            {
                dctBuilder = new DictBuilder();
            }

            return(dctBuilder);
        }
예제 #2
0
파일: Utilities.cs 프로젝트: Zhoner/Delphi
        public int Execute(string input)
        {
            if (input.All(x => x == ' ') || input == "")
            {
                return(0);
            }

            Object[] fields = CParser.Parse(input);

            string command = (string)fields[0];

            if (!cmds.Keys.Contains(command))
            {
                Console.WriteLine("command not found");
                return(-1);
            }

            List <string> flags   = (List <string>)fields[1];
            List <string> paramss = (List <string>)fields[2];

            /* -------------------
             * READ command
             * -------------------*/
            if (command == READ)
            {
                if (paramss == null)
                {
                    dictManger.read("../../input1.txt");
                }
                else if (paramss.Count == 1)
                {
                    dictManger.read(paramss[0]);
                }
                else
                {
                    Console.WriteLine("error: too many params");
                }

                return(0);
            }

            /* -------------------
             * SAVE command
             * -------------------*/
            if (command == SAVE)
            {
                if (paramss == null)
                {
                    dictManger.save("../../input1.txt");
                }
                else if (paramss.Count == 1)
                {
                    dictManger.save(paramss[0]);
                }
                else
                {
                    Console.WriteLine("error: too many params");
                }
                return(0);
            }

            /* -------------------
             * ADD command
             * -------------------*/
            if (command == ADD)
            {
                if (flags.Count == 0)
                {
                    Console.WriteLine("error: choose -w / -d / -n / -e");
                    return(0);
                }

                if (flags[0] == "-z")
                {
                    if (paramss == null || paramss.Count != 2)
                    {
                        Console.WriteLine("ERROR USAGE: add -dct DICT_NAME LANG");
                        return(-1);
                    }

                    dictManger.addDict(
                        DictBuilder.dictBuilder().
                        setName(paramss[0]).
                        setLanguage(paramss[1]).
                        build()
                        );
                    return(0);
                }



                /* -------------------
                 * ADD DEFINITION command
                 * -------------------*/
                if (flags[0] == "-d")
                {
                    if (paramss == null || paramss.Count == 1)
                    {
                        Console.WriteLine("USAGE: add -w WORD DEFINITION");
                        return(0);
                    }

                    Word wrd = dictManger.CurDict().findWord(paramss[0]);

                    if (wrd == null)
                    {
                        Console.WriteLine("Error: Word not found");
                        return(-1);
                    }

                    wrd.addDefinition(new Definition(paramss[1].Replace("\'", "").Replace("\"", "")));
                    return(0);
                }

                /*-----------------------
                 * ADD SYNONYM OR CONTRARY
                 * ------------------------*/

                if (flags[0] == "-s")
                {
                    if (paramss == null || (paramss.Count != 3 && paramss.Count != 2))
                    {
                        Console.WriteLine("USAGE: add -s WORD SYNONYM [N.DEFINITION]");
                        return(0);
                    }


                    Word wrd = dictManger.CurDict().findWord(paramss[0]);
                    if (wrd == null)
                    {
                        Console.WriteLine("Error: Word not found");
                        return(-1);
                    }

                    Definition def;
                    def = wrd.getDefinition(paramss.Count == 3 ? Int32.Parse(paramss[2]) : 0);
                    def.addSynonym(dictManger.CurDict().findWord(paramss[1]));
                }

                if (flags[0] == "-c")
                {
                    if (paramss == null || (paramss.Count != 3 && paramss.Count != 2))
                    {
                        Console.WriteLine("USAGE: add -s WORD CONTRARY [N.DEFINITION]");
                        return(0);
                    }


                    Word wrd = dictManger.CurDict().findWord(paramss[0]);
                    if (wrd == null)
                    {
                        Console.WriteLine("Error: Word not found");
                        return(-1);
                    }

                    Definition def;
                    def = wrd.getDefinition(paramss.Count == 3 ? Int32.Parse(paramss[2]) : 0);
                    def.addContrary(dictManger.CurDict().findWord(paramss[1]));
                }

                /*-----------------------
                 * ADD TRANSLATION  need to be re-thought
                 * ------------------------*/
                if (flags[0] == "-t")
                {
                    if (paramss == null || paramss.Count > 4 || paramss.Count < 2)
                    {
                        Console.WriteLine("USAGE: add -t WORD TRANSLATED LANG [N.DEFINITION]");
                        return(0);
                    }

                    Word wrd = dictManger.CurDict().findWord(paramss[0]);
                    if (wrd == null)
                    {
                        Console.WriteLine("Error: Word not found");
                        return(-1);
                    }

                    // Texts found , List of indexes of dictionaries
                    Tuple <List <Text>, List <int> > tuple = dictManger.find(paramss[1], Dictionary.FLAG_W);
                    int idx = tuple.Item2[0];

                    if (tuple.Item1.Count != 1)
                    {
                        for (int i = 0; i < tuple.Item2.Count; i++)
                        {
                            if (dictManger.getDict(tuple.Item2[i]).Language == paramss[2])
                            {
                                idx = i;
                                break;
                            }
                        }
                    }

                    Word       translated = (Word)tuple.Item1[idx];
                    Definition def        = wrd.getDefinition(paramss.Count == 4 ? Int32.Parse(paramss[3]) : 0);
                    wrd.addTranslation(new Translation(paramss[2], translated), wrd.indexOfDef(def));
                }

                Text   txt    = null;
                string title  = "";
                string origin = "";
                string note   = "";

                /* -------------------
                 * ADD WORD command
                 * -------------------*/
                if (flags[0] == "-w")
                {
                    string type = "";

                    if (paramss == null)
                    {
                        title  = DShell.input("word:");
                        type   = DShell.input("tipo:");
                        origin = DShell.multiline("origin:");
                        note   = DShell.multiline("note:");
                    }

                    if (paramss != null && paramss.Count == 2)
                    {
                        title = paramss[0];
                        type  = paramss[1];
                    }
                    else if (paramss.Count == 1)
                    {
                        title = paramss[0];
                    }
                    else
                    {
                        return(-1);
                    }

                    wrdBuilder.setTitle(title);
                    wrdBuilder.setOrigin(origin);
                    wrdBuilder.setNote(note);
                    wrdBuilder.setType(type);
                    txt = wrdBuilder.build();
                }


                /* -------------------
                 * ADD EXPRESSION command
                 * -------------------*/
                if (flags[0] == "-e")
                {
                    string text        = "";
                    string explanation = "";



                    title = DShell.input("title:");
                    text  = DShell.multiline("text:");

                    txt = new Expression(title, origin, note, text, explanation);
                }

                /* -------------------
                 * ADD NOVEL command
                 * -------------------*/
                if (flags[0] == "-n")
                {
                    string text   = "";
                    string author = "";


                    title  = DShell.input("title:");
                    author = DShell.input("author:");
                    text   = DShell.multiline("text:");


                    txt = new Novel(title, origin, note, text, author);
                }

                if (txt == null)
                {
                    Console.WriteLine("Invalid flag");
                }

                dictManger.CurDict().add(txt);
                return(0);
            }

            /* -------------------
             * CLEAR command
             * -------------------*/
            if (command == CLEAR)
            {
                Console.Clear();
                Console.WriteLine(HEAD);
                return(0);
            }

            /* -------------------
             * EXIT command
             * -------------------*/

            if (command == EXIT)
            {
                return(0);
            }

            /* -------------------
             * HELP command
             * -------------------*/

            if (command == HELP)
            {
                Console.WriteLine("commands:");
                foreach (var var in cmds)
                {
                    Console.WriteLine("   " + var.Key + ":" + "\t" + var.Value);
                }
                return(0);
            }


            /* -------------------
             * LIST command
             * -------------------*/

            if (command == LIST)
            {
                var dict = dictManger.CurDict();

                /* -------------------
                 * LIST all TEXT command
                 * -------------------*/
                if (flags == null)
                {
                    Console.WriteLine(dict.list());
                    return(0);
                }

                /* ----------------------------
                 * LIST DICTIONARIES command
                 * --------------------------*/

                if (flags[0] == "-z")
                {
                    Console.WriteLine(dictManger.listDicts());
                    return(0);
                }

                /* -------------------
                 * LIST WORDS command
                 * -------------------*/
                //show flag
                int sFLAG = 0;

                if (flags[0] == "-w")
                {
                    sFLAG = sFLAG | Dictionary.FLAG_W;
                }

                /* -------------------
                 * LIST EXPRESSIONS command
                 * -------------------*/
                if (flags[0] == "-e")
                {
                    sFLAG = sFLAG | Dictionary.FLAG_E;
                }

                /* -------------------
                 * LIST NOVELS command
                 * -------------------*/
                if (flags[0] == "-n")
                {
                    sFLAG = sFLAG | Dictionary.FLAG_N;
                }

                Console.WriteLine(dict.list(sFLAG));
                return(0);
            }


            /* -------------------
             * DELETE command
             * -------------------*/
            if (command == REMOVE)
            {
                if (paramss == null)
                {
                    Console.WriteLine("ERROR: params missing");
                    return(-1);
                }
                else if ((paramss.Count != 2 && paramss.Count != 1))
                {
                    Console.WriteLine("USAGE: remove -d WORD N*DEFINITION");
                    return(-1);
                }


                Text txt = dictManger.CurDict().find(paramss[0]);


                if (flags.Count != 0 && flags[0] == "-d")
                {
                    if (((Word)txt).removeDefinition(Int32.Parse(paramss[1]) - 1) == null)
                    {
                        Console.WriteLine("ERROR: index of definition out of bound");
                        return(-1);
                    }
                    return(0);
                }

                if (flags.Count == 0 && dictManger.CurDict().remove(txt))
                {
                    Console.WriteLine("ERROR: word/expression/novel not found");
                    return(-1);
                }



                return(0);
            }

            /*----------------------
             * FIND
             * -------------------*/
            if (command == FIND)
            {
                if (flags.Count == 0)
                {
                    Text txt = dictManger.CurDict().find(paramss[0]);
                    if (txt != null)
                    {
                        Console.WriteLine("found:" + txt.title);
                    }
                    else
                    {
                        Console.WriteLine("not found :" + paramss[0]);
                    }
                    return(0);
                }

                if (flags[0] == "-w")
                {
                    if (paramss == null)
                    {
                        Console.WriteLine("ERROR: params missing");
                        return(-1);
                    }

                    Word wrd = dictManger.CurDict().findWord(paramss[0]);
                    if (wrd != null)
                    {
                        Console.WriteLine("found word:" + wrd.title);
                    }
                    else
                    {
                        Console.WriteLine("not found word:" + paramss[0]);
                    }
                    return(0);
                }

                if (flags[0] == "-e")
                {
                    if (paramss == null)
                    {
                        Console.WriteLine("ERROR: params missing");
                        return(-1);
                    }

                    Expression exp = dictManger.CurDict().findExp(paramss[0]);
                    if (exp != null)
                    {
                        Console.WriteLine("found word:" + exp.title);
                    }
                    else
                    {
                        Console.WriteLine("not found word:" + paramss[0]);
                    }
                    return(0);
                }

                if (flags[0] == "-n")
                {
                    if (paramss == null)
                    {
                        Console.WriteLine("ERROR: params missing");
                        return(-1);
                    }

                    Novel nvl = dictManger.CurDict().findNovel(paramss[0]);
                    if (nvl != null)
                    {
                        Console.WriteLine("found novel:" + nvl.title);
                    }
                    else
                    {
                        Console.WriteLine("not found word:" + paramss[0]);
                    }
                    return(0);
                }

                if (flags[0] == "-p")
                {
                    if (paramss == null)
                    {
                        Console.WriteLine("ERROR: params missing");
                        return(-1);
                    }

                    List <Text> texts = dictManger.CurDict().PBS(paramss[0]);
                    foreach (Text text in texts)
                    {
                        if (text != null)
                        {
                            Console.WriteLine("found text:" + text.title);
                        }
                        else
                        {
                            Console.WriteLine("not found word:" + paramss[0]);
                        }
                    }
                    return(0);
                }
            }

            /*----------------------
             * REMIND
             * -------------------*/

            if (command == REMIND)
            {
                int n = 5;
                if (paramss != null)
                {
                    n = int.Parse(paramss[0]);
                }

                List <string> list_wrd = new List <string>();

                List <Word> words = dictManger.CurDict().wrdRemind(n);
                foreach (Word w in words)
                {
                    list_wrd.Add(w.title);
                }
                Console.WriteLine(list_wrd);
                return(0);
            }

            /*----------------------
             * SHOW
             * -------------------*/
            if (command == SHOW)
            {
                if (paramss == null || paramss.Count != 1)
                {
                    Console.WriteLine("USAGE: show -w WORD");
                    return(0);
                }
                int find_flags = 0;

                if (flags.Count != 0)
                {
                    if (flags[0] == "-w")
                    {
                        find_flags |= Dictionary.FLAG_W;
                    }
                    else if (flags[0] == "-n")
                    {
                        find_flags |= Dictionary.FLAG_N;
                    }
                    else if (flags[0] == "-e")
                    {
                        find_flags |= Dictionary.FLAG_E;
                    }
                }

                Text txtFound = dictManger.CurDict().find(paramss[0], find_flags);

                if (txtFound == null)
                {
                    Console.WriteLine("error: word/expression/novel not found");
                    return(-1);
                }
                else
                {
                    Console.WriteLine(txtFound.toString());
                }

                return(0);
            }


            /*----------------------
             * CHANGE
             * -------------------*/
            if (command == CHANGE)
            {
                if (paramss == null || paramss.Count != 1)
                {
                    Console.WriteLine("ERROR, USAGE: change INDEX");
                    return(-1);
                }

                dictManger.setCurDict(Int32.Parse(paramss[0]));
            }


            Console.WriteLine($"{input} not found");
            return(1);
        }