---

/home/vlg/develop/gwavmerger/src/NameUtils.cpp

Go to the documentation of this file.

// -*- c++ -*-
//------------------------------------------------------------------------------
//                              NameUtils.cpp
//------------------------------------------------------------------------------
// $Id: NameUtils.cpp,v 1.6 2003/02/07 05:15:10 vlg Exp $
//------------------------------------------------------------------------------
//  Copyright (c) 2002 by Vladislav Grinchenko
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version
//  2 of the License, or (at your option) any later version.
//------------------------------------------------------------------------------
// 06/28/2002 VLG  Created
//------------------------------------------------------------------------------

#include <stdio.h>
#include <fstream>
#include <sstream>
using std::ostringstream;
using std::ifstream;
using std::ofstream;
using std::ios;

#include "gWavMerger-main.h"
#include "NameUtils.h"

/*******************************************************************************
 Local defines
*******************************************************************************/

/*******************************************************************************
 Parse format from fully qualified sequence of names. A fully quialified
 name is of the format:

    <prefix><number>.wav

 The sequence might have "gap" entires which are ignored.
 If <number> is not in uniform format, 00..0x, then the most generic
 "%d" is returned.

 For example, ru_034.wav is a fully qualified name with
 
     <prefix>="ru_"
     <number>="034" 

 The printf format of this name is "%03d".

 Return: On success, printf()-like format is returned.

         If failed, an empty string is returned. An empty string might result
         in case if not all names in sequence have the same prefix.
*******************************************************************************/
string

nameutils::parse_format (const string& prefix_, vector<string>& vs_)
{
    static const char self[]="nameutils::parse_format";
    trace(self);

    string ret;
    string name;
    int i;
    int len;
    bool is_varlen = false;
    bool is_numeric = true;
    i = len = 0;

    vector<string>::const_iterator cit = vs_.begin ();

    while (cit != vs_.end ()) {
        DL((TRACE,"---------------------\n"));
        DL((TRACE,"Parsing \"%s\"\n", (*cit).c_str ()));

        if (*cit != "gap") {
            //          name = parse_seq_number (*cit, prefix_);
            name = *cit;
            // DL((TRACE,"parse_seq_number () = \"%s\"\n", name.c_str ()));
            if (name.length () == 0) {
                return ret;
            }
            i = strtol (name.c_str (), (char **) NULL, 10);
            DL((TRACE,"Parsed number %d < %d < %d\n",LONG_MIN,i,LONG_MAX));
            if (i == LONG_MIN || i == LONG_MAX) {
                DL((TRACE,"Set is_numeric = false\n"));
                is_numeric = false;
                break;
            }
            if (len == 0) {
                len = name.length ();
                DL((TRACE,"Set len = %d\n", len));
            }
            if (name.length () != len) {
                DL((TRACE,"Set is_varlen = true (%d != %d)\n", 
                    name.length (), len));
                is_varlen = true;
                len = max2 (len, name.length ());
                DL((TRACE,"Set len = %d\n", len));
            }
        }
        cit++;
    }
    DL((TRACE,"is_numeric = %s, is_varlen = %s\n", is_numeric?"true":"false",
        is_varlen?"true":"false"));

    if (is_numeric == true) {
        if (is_varlen == false) {
            ostringstream os;
            os << "%0" << len << "d";
            ret = os.str ();
        }
        else {
            ret = "%d";
        }
    }
    DL((TRACE,"Parsed format: \"%s\"\n", ret.c_str ()));
    return ret;
}

/*******************************************************************************
 Extract the sequence number from a file name. A file name is of the format:

    <prefix><seq_number>.wav

 For example, ru_034.wav is a fully qualified name with
 
     <prefix>="ru_"
     <seq_number>="034" 

 Return: parsed <seq_number> if success; 
         empty string if failed
*******************************************************************************/
string

nameutils::parse_seq_number (const string& name_, const string& prefix_)
{
    static const char self[]="nameutils::parse_seq_number";
    trace(self);

    string s (name_);
    string::size_type idx = string::npos;

    DL((TRACE,"Parsing(0) \"%s\", prefix_ = \"%s\"\n", s.c_str (),
        prefix_.c_str ()));

    if ((idx = s.find (prefix_)) == 0) {
        s.erase (0, prefix_.length ());
        DL((TRACE,"Parsing(1) \"%s\"\n", s.c_str ()));
        idx = s.find ('.');
        if (idx != string::npos) {
            if (s.substr (idx) == ".wav") {
                s.replace (idx, name_.size (), "");
                DL((TRACE,"Parsing(2) \"%s\"\n", s.c_str ()));
                return s;
            }
        }
    }
    return ("");
}


/*******************************************************************************
 Format sequence number according to the supplied format.
 For example, if seqnum = 34 and format "%03d" the result will be 034.

 Return: formatted sequence number.
*******************************************************************************/
string

nameutils::format_seqnum (int seqnum_, const string& fmt_)
{
    char buf [PATH_MAX];

    snprintf (buf, PATH_MAX, fmt_.c_str (), seqnum_);
    return string (buf);
}

/*******************************************************************************
 Take fully qualified file name in form <prefix><seq_number>.wav and make a 
 fully qualified name of the file with offset
    <path>/<prefix><seq_number+offset>.wav

 Return: fully qualified name or an empty string if parsing sequence number
         failed.
*******************************************************************************/
string

nameutils::make_name_with_offset (const string& name_, const string& fmt_,
                       const string& prefix_, const string& dirpath_, 
                       int offset_)
{
    static const char self[]="nameutils::make_name_with_offset";
    trace(self);

    string s (name_);
    string::size_type idx;

    DL((TRACE,"\n\tname_=\"%s\"\n\tfmt_=\"%s\"\n\tprefix_=\"%s\"\n",
        name_.c_str (), fmt_.c_str(), prefix_.c_str ()));
    
    if ((idx = s.find (dirpath_)) == 0) {
        s.erase (0, dirpath_.length ()+1);
    }
    s = parse_seq_number (s, prefix_);

    if (s.length () == 0) {
        return s;
    }
    return (dirpath_ + "/" + prefix_ 
            + format_seqnum (atoi (s.c_str ()) + offset_, fmt_) 
            + string (".wav"));
}

/*******************************************************************************
 Take file name in form <path>/<prefix><seq_number>.wav and make a fully 
 qualified name of the file that follows: <path>/<prefix><seq_number-1>.wav

 Return: fully qualified name or an empty string if parsing sequence number
         failed.
*******************************************************************************/
string

nameutils::make_prev_name (const string& name_, const string& fmt_,
                const string& prefix_, const string& dirpath_)
{
    return make_name_with_offset (name_, fmt_, prefix_, dirpath_, -1);
}

/*******************************************************************************
 Take file name in form <path>/<prefix><seq_number>.wav and make a fully 
 qualified name of the file that follows: <path>/<prefix><seq_number+1>.wav

 Return: fully qualified name or an empty string if parsing sequence number
         failed.
*******************************************************************************/
string

nameutils::make_next_name (const string& name_, const string& fmt_,
                const string& prefix_, const string& dirpath_)
{
    return make_name_with_offset (name_, fmt_, prefix_, dirpath_, +1);
}


/*******************************************************************************
 Fast file copy.

 RETURN: 0 on success; -1 if either source or destination cannot be opened.
*******************************************************************************/
int

nameutils::fast_copy (const string& src_, const string& dest_)
{
    ifstream source (src_.c_str (), std::ios::in);
    ofstream destination (dest_.c_str (), std::ios::out);

    if (!(source.good () || destination.good ())) {
        return -1;
    }

    destination << source.rdbuf();
    source.close ();
    destination.close ();
    return 0;
}
    

---