Пример #1
0
        /// <summary>
        /// Returns the data that should be placed in the JTable
        /// at the given row and column. </summary>
        /// <param name="row"> the row for which to return data. </param>
        /// <param name="col"> the column for which to return data. </param>
        /// <returns> the data that should be placed in the JTable at the given row and col. </returns>
        public virtual object getValueAt(int row, int col)
        {
            if (_sortOrder != null)
            {
                row = _sortOrder[row];
            }

            StateMod_StreamGage sg = (StateMod_StreamGage)_data.get(row);

            switch (col)
            {
            case COL_ID:
                return(sg.getID());

            case COL_NAME:
                return(sg.getName());

            case COL_NODE_ID:
                return(sg.getCgoto());

            case COL_DAILY_ID:
                return(sg.getCrunidy());

            default:
                return("");
            }
        }
        /// <summary>
        /// Write the new (updated) stream gage stations file.  If an original file is
        /// specified, then the original header is carried into the new file. </summary>
        /// <param name="infile"> Name of old file or null if no old file to update. </param>
        /// <param name="outfile"> Name of new file to create (can be the same as the old file). </param>
        /// <param name="theRivs"> list of StateMod_StreamGage to write. </param>
        /// <param name="newcomments"> New comments to write in the file header. </param>
        /// <param name="do_daily"> Indicates whether daily modeling fields should be written. </param>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static void writeStateModFile(String infile, String outfile, java.util.List<StateMod_StreamGage> theRivs, java.util.List<String> newcomments, boolean do_daily) throws Exception
        public static void writeStateModFile(string infile, string outfile, IList <StateMod_StreamGage> theRivs, IList <string> newcomments, bool do_daily)
        {
            PrintWriter    @out = null;
            IList <string> commentIndicators = new List <string>(1);

            commentIndicators.Add("#");
            IList <string> ignoredCommentIndicators = new List <string>(1);

            ignoredCommentIndicators.Add("#>");
            string routine = "StateMod_StreamGage.writeStateModFile";

            if (Message.isDebugOn)
            {
                Message.printDebug(2, routine, "Writing stream gage stations to file \"" + outfile + "\" using \"" + infile + "\" header...");
            }

            try
            {
                // Process the header from the old file...
                @out = IOUtil.processFileHeaders(IOUtil.getPathUsingWorkingDir(infile), IOUtil.getPathUsingWorkingDir(outfile), newcomments, commentIndicators, ignoredCommentIndicators, 0);

                string cmnt             = "#>";
                string iline            = null;
                string format           = null;
                StateMod_StreamGage riv = null;

                @out.println(cmnt + " *******************************************************");
                @out.println(cmnt + "  Stream Gage Station File");
                @out.println(cmnt);
                @out.println(cmnt + "     format:  (a12, a24, a12, 1x, a12)");
                @out.println(cmnt);
                @out.println(cmnt + "  ID         crunid:  Station ID");
                @out.println(cmnt + "  Name       runnam:  Station name");
                @out.println(cmnt + "  River ID    cgoto:  River node with stream gage");
                @out.println(cmnt + "  Daily ID  crunidy:  Daily stream station ID.");
                @out.println(cmnt);
                @out.println(cmnt + "    ID              Name           River ID     Daily ID   ");
                @out.println(cmnt + "---------eb----------------------eb----------exb----------e");
                if (do_daily)
                {
                    format = "%-12.12s%-24.24s%-12.12s %-12.12s";
                }
                else
                {
                    format = "%-12.12s%-24.24s%-12.12s";
                }
                @out.println(cmnt);
                @out.println(cmnt + "EndHeader");
                @out.println(cmnt);

                int num = 0;
                if (theRivs != null)
                {
                    num = theRivs.Count;
                }
                IList <object> v = new List <object>(5);
                for (int i = 0; i < num; i++)
                {
                    riv = theRivs[i];
                    v.Clear();
                    v.Add(riv.getID());
                    v.Add(riv.getName());
                    v.Add(riv.getCgoto());
                    if (do_daily)
                    {
                        v.Add(riv.getCrunidy());
                    }
                    iline = StringUtil.formatString(v, format);
                    @out.println(iline);
                }
            }
            catch (Exception e)
            {
                Message.printWarning(3, routine, e);
                throw e;
            }
            finally
            {
                if (@out != null)
                {
                    @out.flush();
                    @out.close();
                }
            }
        }
        /// <summary>
        /// Writes a list of StateMod_StreamGage objects to a list file.  A header is
        /// printed to the top of the file, containing the commands used to generate the
        /// file.  Any strings in the body of the file that contain the field delimiter will be wrapped in "...". </summary>
        /// <param name="filename"> the name of the file to which the data will be written. </param>
        /// <param name="delimiter"> the delimiter to use for separating field values. </param>
        /// <param name="update"> whether to update an existing file, retaining the current
        /// header (true) or to create a new file with a new header. </param>
        /// <param name="data"> the list of objects to write. </param>
        /// <param name="newComments"> list of comments to add at the top of the file. </param>
        /// <exception cref="Exception"> if an error occurs. </exception>
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static void writeListFile(String filename, String delimiter, boolean update, java.util.List<StateMod_StreamGage> data, java.util.List<String> newComments) throws Exception
        public static void writeListFile(string filename, string delimiter, bool update, IList <StateMod_StreamGage> data, IList <string> newComments)
        {
            int size = 0;

            if (data != null)
            {
                size = data.Count;
            }

            IList <string> fields = new List <string>();

            fields.Add("ID");
            fields.Add("Name");
            fields.Add("NodeID");
            fields.Add("DailyID");
            int fieldCount = fields.Count;

            string[] names   = new string[fieldCount];
            string[] formats = new string[fieldCount];
            int      comp    = StateMod_DataSet.COMP_STREAMGAGE_STATIONS;
            string   s       = null;

            for (int i = 0; i < fieldCount; i++)
            {
                s          = fields[i];
                names[i]   = StateMod_Util.lookupPropValue(comp, "FieldName", s);
                formats[i] = StateMod_Util.lookupPropValue(comp, "Format", s);
            }

            string oldFile = null;

            if (update)
            {
                oldFile = IOUtil.getPathUsingWorkingDir(filename);
            }

            int                 j    = 0;
            PrintWriter         @out = null;
            StateMod_StreamGage gage = null;
            IList <string>      commentIndicators = new List <string>(1);

            commentIndicators.Add("#");
            IList <string> ignoredCommentIndicators = new List <string>(1);

            ignoredCommentIndicators.Add("#>");
            string[]      line   = new string[fieldCount];
            StringBuilder buffer = new StringBuilder();

            try
            {
                // Add some basic comments at the top of the file.  Do this to a copy of the
                // incoming comments so that they are not modified in the calling code.
                IList <string> newComments2 = null;
                if (newComments == null)
                {
                    newComments2 = new List <string>();
                }
                else
                {
                    newComments2 = new List <string>(newComments);
                }
                newComments2.Insert(0, "");
                newComments2.Insert(1, "StateMod stream gage stations as a delimited list file.");
                newComments2.Insert(2, "");
                @out = IOUtil.processFileHeaders(oldFile, IOUtil.getPathUsingWorkingDir(filename), newComments2, commentIndicators, ignoredCommentIndicators, 0);

                for (int i = 0; i < fieldCount; i++)
                {
                    if (i > 0)
                    {
                        buffer.Append(delimiter);
                    }
                    buffer.Append("\"" + names[i] + "\"");
                }

                @out.println(buffer.ToString());

                for (int i = 0; i < size; i++)
                {
                    gage = (StateMod_StreamGage)data[i];

                    line[0] = StringUtil.formatString(gage.getID(), formats[0]).Trim();
                    line[1] = StringUtil.formatString(gage.getName(), formats[1]).Trim();
                    line[2] = StringUtil.formatString(gage.getCgoto(), formats[2]).Trim();
                    line[3] = StringUtil.formatString(gage.getCrunidy(), formats[3]).Trim();

                    buffer = new StringBuilder();
                    for (j = 0; j < fieldCount; j++)
                    {
                        if (j > 0)
                        {
                            buffer.Append(delimiter);
                        }
                        if (line[j].IndexOf(delimiter, StringComparison.Ordinal) > -1)
                        {
                            line[j] = "\"" + line[j] + "\"";
                        }
                        buffer.Append(line[j]);
                    }

                    @out.println(buffer.ToString());
                }
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                if (@out != null)
                {
                    @out.flush();
                    @out.close();
                }
            }
        }