WoStransform.cc

Go to the documentation of this file.

/* WoStransform.cc */
/* program to transform web-of-science file entries */

/* Copyright (C) 2002 - 2009, Bernd Speiser */
/* This file is part of WoStransform.

WoStransform 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.

WoStransform is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
*/

#include <iostream>
#include <fstream>
#include <vector>
#include <cstring>
#include <cstdlib>

#include "WoSentry.h"

using namespace WoStransform;

int main (int argc, char *argv[])
{
  if (argc == 1)
  {
    std::cout << "usage: WoStransform [options] -o output_file input_file(s)" 
         << std::endl << "or: WoStransform --version" << std::endl;

    exit (1);
  }

  if (!strcmp (argv[1], "--version"))
  {
      std::cout << "WoStransform, version 1.3" << std::endl;

      exit (0);
  }

  std::cout << "starting WoStransform - transformation of web-of-science " 
       << std::endl 
       << "                        files into bibtex format" << std::endl
       << "version 1.3, Copyright (C) 2002 - 2009, Bernd Speiser" << std::endl
       << "WoStransform comes with ABSOLUTELY NO WARRANTY; for details see"
       << std::endl 
       << "the General Public License." << std::endl
       << "This is free software, and you are welcome to redistribute it"
       << std::endl 
       << "under certain conditions; see the General Public License for "
          "details." 
       << std::endl;

  if (argc < 4)
  {
    std::cout << "wrong number of arguments; " << std::endl <<
            "usage: WoStransform [options] -o output_file input_file(s)" 
         << std::endl << "or: WoStransform --version" << std::endl;

    exit (1);
  }

  int outputfile_pointer = 0;

  bool verbose = false;

  for (int i = 1; i < argc; i++)
  {
    if (!strcmp (argv[i], "--verbose"))
      verbose = true;

    else if (!strcmp (argv[i],"-o"))
      outputfile_pointer = i + 1;
  }

  if (!outputfile_pointer)
  {
    std::cout << "no outputfile given; usage: WoStransform "
                 "[options] -o output_file input_file(s) " << std::endl;

    exit (1);
  }

  std::vector <WoSentry *> entries;

  const int buffersize = 1000;

  char buffer[buffersize];

  int entry_counter = 0;

  for (int j = outputfile_pointer + 1; j < argc; j++)
  {
    std::ifstream WoSinput (argv[j]);

    if (!WoSinput)
    {
      std::cout << "can't open file: " << argv[j] << std::endl;

      exit (1);
    }

    if (verbose)
      std::cout << "reading input file: `" << argv[j] << "´" << std::endl;

    WoSinput.getline (buffer, buffersize);

    if (strcmp (buffer, "FN ISI Export Format"))
      std::cout << "file `" << argv[j] 
           << "´ not in recognized web-of-science format, skipped" 
                                                         << std::endl;
    else
    {
      int line_number = 1;

      std::string bufferstring;

      std::string entrytext;

      while (WoSinput.getline (buffer, buffersize))
      {
        line_number++;

        bufferstring = buffer;

        bufferstring += '\n';

        if (bufferstring.substr (0,3) == "PT ")
        {
          entrytext += bufferstring;

          if (bufferstring.substr (3) == "Journal\n" 
                                    || bufferstring.substr (3) == "J\n"
                                    || bufferstring.substr (3) == "C\n")
          {
            if (verbose)
              std::cout << "generating new entry of type " 
                << bufferstring.substr 
                                  (3, bufferstring.find_last_of ('\n') -
                  bufferstring.find_first_not_of (" ", 3)) << std::endl;

            entry_counter++;

            WoSentry *entry = new JournalWoSentry;

            while (WoSinput.getline (buffer, buffersize))
            {
              line_number++;

              bufferstring = buffer;

              bufferstring += '\n';

              if (bufferstring.substr (0,2) == "ER")
              {
                *entry << entrytext;

                entries.push_back (entry);

                entrytext = "";

                break;
              }

              entrytext += bufferstring;
            }
          }

          else if (bufferstring.substr (3) == "Book in series\n"
                                     || bufferstring.substr (3) == "S\n") 
          {
            if (verbose)
              std::cout << "generating new entry of type " 
                << bufferstring.substr 
                                  (3, bufferstring.find_last_of ('\n') -
                  bufferstring.find_first_not_of (" ", 3)) << std::endl;

            WoSentry *entry = new BookinseriesWoSentry;

            while (WoSinput.getline (buffer, buffersize))
            {
              line_number++;

              bufferstring = buffer;

              bufferstring += '\n';

              if (bufferstring.substr (0,2) == "ER")
              {
                *entry << entrytext;

                entries.push_back (entry);

                entrytext = "";

                break;
              }

              entrytext += bufferstring;
            }
          }

          else
          {
            std::cout << "unknown publication type `" 
              << bufferstring.substr (3, 
                bufferstring.find_last_of ('\n') - 
                  bufferstring.find_first_not_of (" ", 3)) << 
                    "' in line "<< line_number << " of file " << argv[j]
                                                           << std::endl;
          }
        }
      }
    }
  }

  std::vector<WoSentry *>::const_iterator entrypointer;

  std::cout << "writing to " << argv[outputfile_pointer] << std::endl;

  std::ofstream bibtexoutput (argv[outputfile_pointer]);

  if (!bibtexoutput)
  {
    std::cout << "can't open file: " 
                               << argv[outputfile_pointer] << std::endl;
    exit (1);
  }

  for (entrypointer = entries.begin (); 
                        entrypointer != entries.end (); ++ entrypointer)
  {
    (*entrypointer)->deconstruct ();

    (*entrypointer)->format_authors ();

    (*entrypointer)->output (bibtexoutput);
  }

  if (entry_counter == 1)
    std::cout << entry_counter << " entry generated " << std::endl;

  else if (entry_counter > 1)
    std::cout << entry_counter << " entries generated " << std::endl;

  exit (0);
}

void JournalWoSentry::deconstruct (void)
{
  std::string::size_type title_begin;
  std::string::size_type lineend;

  title_begin = text.find ("\nTI"); 

  title_begin = text.find_first_not_of (" ", title_begin + 3);

  title = "";

  while (title_begin != std::string::npos)
  {
    lineend = text.find ("\n", title_begin);

    title += text.substr (title_begin, lineend - title_begin);

    if (text.at (lineend + 1) != ' ')
      break;

    title_begin = lineend + 3;
  }

  std::string::size_type journal_begin;

  journal_begin = text.find ("\nJI"); 

  journal_begin = text.find_first_not_of (" ", journal_begin + 3);

  journal = "";

  while (journal_begin != std::string::npos)
  {
    lineend = text.find ("\n", journal_begin);

    journal += text.substr (journal_begin, lineend - journal_begin);

    if (text.at (lineend + 1) != ' ')
      break;

    journal_begin = lineend + 3;
  }

  std::string::size_type authors_begin;

  authors_begin = text.find ("\nAU"); 

  authors_begin = text.find_first_not_of (" ", authors_begin + 3);

  authors = "";

  while (authors_begin != std::string::npos)
  {
    lineend = text.find ("\n", authors_begin);

    authors += text.substr (authors_begin, lineend - authors_begin);

    authors += ";";

    if (text.at (lineend + 1) != ' ')
      break;

    authors_begin = lineend + 3;
  }

  std::string::size_type printing_year_begin;

  printing_year_begin = text.find ("\nPY"); 

  printing_year_begin 
                = text.find_first_not_of (" ", printing_year_begin + 3);

  printing_year = "";

  lineend = text.find ("\n", printing_year_begin);

  printing_year += 
       text.substr (printing_year_begin, lineend - printing_year_begin);

  std::string::size_type begin_page_begin;

  begin_page_begin = text.find ("\nBP"); 

  begin_page_begin 
                = text.find_first_not_of (" ", begin_page_begin + 3);

  begin_page = "";

  lineend = text.find ("\n", begin_page_begin);

  begin_page += 
       text.substr (begin_page_begin, lineend - begin_page_begin);

  std::string::size_type end_page_begin;

  end_page_begin = text.find ("\nEP"); 

  end_page_begin 
                = text.find_first_not_of (" ", end_page_begin + 3);

  end_page = "";

  lineend = text.find ("\n", end_page_begin);

  end_page += 
       text.substr (end_page_begin, lineend - end_page_begin);

  std::string::size_type volume_begin;

  volume_begin = text.find ("\nVL"); 

  volume = "";

  if (volume_begin != std::string::npos)
  {
    volume_begin = text.find_first_not_of (" ", volume_begin + 3);

    lineend = text.find ("\n", volume_begin);

    volume += text.substr (volume_begin, lineend - volume_begin);
  }
}

std::ofstream & JournalWoSentry::output (std::ofstream &outstream)
{
  outstream << "@article{" << key << "," << std::endl;

  outstream << "author = {" << authors << "}," << std::endl;

  outstream << "journal = {" << journal << "}," << std::endl;

  if (!volume.empty ())
    outstream << "volume = {" << volume << "}," << std::endl;

  outstream << "pages = {" << begin_page << "~--~" << end_page 
                                                   << "}," << std::endl;

  outstream << "year = {" << printing_year << "}," << std::endl;

  outstream << "title = {" << title << "}," << std::endl;

  outstream << "topics = {}," << std::endl;
  outstream << "copy = {}" << std::endl;

  outstream << "}" << std::endl;
}

void WoSentry::format_authors (void)
{
  std::string buffer = authors;

  authors = "";

  std::string author;
  std::string correct_author;
  std::string lastname;
  std::string firstnames;
  std::string firstnames_string;

  std::vector<std::string> lastnames;

  std::string::size_type begin_author;
  std::string::size_type end_author;
  std::string::size_type end_authorstring;
  std::string::size_type end_firstname;
  std::string::size_type index;

  begin_author = buffer.find_first_not_of (" ");  
  end_author = buffer.find (";", begin_author);  
  end_authorstring = buffer.find_last_of (";");  

  while (end_author <= end_authorstring)
  {
    author = buffer.substr (begin_author, end_author - begin_author);

    end_firstname = author.find_last_of (" ");

    lastname = author.substr (0, author.find_last_of (","));

    lastnames.push_back (lastname);

    firstnames_string 
                  = author.substr (author.find_last_of (" ") + 1) + " ";

    firstnames 
      = firstnames_string.substr 
                            (firstnames_string.find_first_not_of (" "));

    std::string::iterator pointer = firstnames.begin ();

    index = firstnames.find_first_not_of (" ");

    int idx = 0;

    while (firstnames.at(idx) != ' ')
    {
      firstnames.insert (++index, ".");

      index++;

      idx += 2;
    }

    correct_author = firstnames + lastname;

    if (authors.empty ())
      authors += correct_author;

    else
      authors = authors + " and " + correct_author;

    if (end_author == end_authorstring)
      break;

    begin_author = buffer.find_first_not_of (" ", ++end_author);  
    end_author = buffer.find (";", begin_author);  

  }

  int authornumber = lastnames.size ();

  std::vector<std::string>::const_iterator lastname_pointer;

  lastname_pointer = lastnames.begin ();

  if (authornumber == 1)
    key = *lastname_pointer + "_" + printing_year;

  else if (authornumber == 2)
    key = *lastname_pointer + "/" + *(lastname_pointer + 1) + "_" 
                                                                + printing_year;

  else if (authornumber > 2)
    key = *lastname_pointer + "/" + *(lastname_pointer + 1) + "/etal_" 
                                                                + printing_year;

  else
    std::cout << "no author found!!!" << std::endl;

}

void BookinseriesWoSentry::deconstruct (void)
{
  std::string::size_type title_begin;
  std::string::size_type lineend;

  title_begin = text.find ("\nTI"); 

  title_begin = text.find_first_not_of (" ", title_begin + 3);

  title = "";

  while (title_begin != std::string::npos)
  {
    lineend = text.find ("\n", title_begin);

    title += text.substr (title_begin, lineend - title_begin);

    if (text.at (lineend + 1) != ' ')
      break;

    title_begin = lineend + 3;
  }

  std::string::size_type series_begin;

  series_begin = text.find ("\nSE"); 

  series_begin = text.find_first_not_of (" ", series_begin + 3);

  series = "";

  while (series_begin != std::string::npos)
  {
    lineend = text.find ("\n", series_begin);

    series += text.substr (series_begin, lineend - series_begin);

    if (text.at (lineend + 1) != ' ')
      break;

    series_begin = lineend + 3;
  }

  std::string::size_type authors_begin;

  authors_begin = text.find ("\nAU"); 

  authors_begin = text.find_first_not_of (" ", authors_begin + 3);

  authors = "";

  while (authors_begin != std::string::npos)
  {
    lineend = text.find ("\n", authors_begin);

    authors += text.substr (authors_begin, lineend - authors_begin);

    authors += ";";

    if (text.at (lineend + 1) != ' ')
      break;

    authors_begin = lineend + 3;
  }

  std::string::size_type printing_year_begin;

  printing_year_begin = text.find ("\nPY"); 

  printing_year_begin 
                = text.find_first_not_of (" ", printing_year_begin + 3);

  printing_year = "";

  lineend = text.find ("\n", printing_year_begin);

  printing_year += 
       text.substr (printing_year_begin, lineend - printing_year_begin);

  std::string::size_type begin_page_begin;

  begin_page_begin = text.find ("\nBP"); 

  begin_page_begin 
                = text.find_first_not_of (" ", begin_page_begin + 3);

  begin_page = "";

  lineend = text.find ("\n", begin_page_begin);

  begin_page += 
       text.substr (begin_page_begin, lineend - begin_page_begin);

  std::string::size_type end_page_begin;

  end_page_begin = text.find ("\nEP"); 

  end_page_begin 
                = text.find_first_not_of (" ", end_page_begin + 3);

  end_page = "";

  lineend = text.find ("\n", end_page_begin);

  end_page += 
       text.substr (end_page_begin, lineend - end_page_begin);

  std::string::size_type volume_begin;

  volume_begin = text.find ("\nVL"); 

  volume = "";

  if (volume_begin != std::string::npos)
  {
    volume_begin = text.find_first_not_of (" ", volume_begin + 3);

    lineend = text.find ("\n", volume_begin);

    volume += text.substr (volume_begin, lineend - volume_begin);
  }
}

std::ofstream & BookinseriesWoSentry::output (std::ofstream &outstream)
{
  outstream << "@article{" << key << "," << std::endl;

  outstream << "author = {" << authors << "}," << std::endl;

  outstream << "journal = {" << series << "}," << std::endl;

  if (!volume.empty ())
    outstream << "volume = {" << volume << "}," << std::endl;

  outstream << "pages = {" << begin_page << "~--~" << end_page 
                                                   << "}," << std::endl;

  outstream << "year = {" << printing_year << "}," << std::endl;

  outstream << "title = {" << title << "}," << std::endl;

  outstream << "topics = {}," << std::endl;
  outstream << "copy = {}" << std::endl;

  outstream << "}" << std::endl;
}

---