U7file.cc

Go to the documentation of this file.

/*
Copyright (C) 2000  Dancer A.L Vesperman

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.

This program 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.
*/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#ifndef ALPHA_LINUX_CXX
#  include <cstdio>
#endif
#include <iostream>

#include "U7file.h"
#include "Flex.h"
#include "IFF.h"
#include "Table.h"
#include "Flat.h"
#include "exceptions.h"
#include "utils.h"

using std::cerr;
using std::endl;
using std::size_t;
using std::FILE;
using std::string;


#define TRY_FILE_TYPE(uf,CLASS_NAME)  \
  if(!uf) \
  try { \
    uf=new CLASS_NAME(s); \
  } catch(const wrong_file_type_exception &)  \
    { \
    }

U7file  *U7FileManager::get_file_object(const string &s)
{
  U7file  *uf=0;
  if(file_list.count(s))
  {
    return file_list[s];
  }
  // Not in our cache. Attempt to figure it out.
  
  TRY_FILE_TYPE(uf,IFF);
#ifndef PENTAGRAM
  TRY_FILE_TYPE(uf,Flex);
#endif
  TRY_FILE_TYPE(uf,Table);
  TRY_FILE_TYPE(uf,Flat);

  // Failed
  if (!uf) {
    throw (file_open_exception((const string &) s));
    return 0;
  }

  file_list[s]=uf;
  return uf;
}

U7FileManager *U7FileManager::get_ptr(void)
{
  if(!self)
    new U7FileManager();  // self gets the pointer, so it's okay
          // This might look like it creates a
          // leak, but this is a singleton object
  return self;
}

void U7FileManager::reset()
{
  std::map<std::string,U7file *>::iterator i;

  for (i = file_list.begin(); i != file_list.end(); ++i)
    delete (*i).second;

  file_list.clear();
}
  

U7FileManager::~U7FileManager() {}

U7FileManager   *U7FileManager::self=0;

U7FileManager::U7FileManager()
{
  if(self) {
    throw exclusive();
    std::exit(-1);
  }
  else
    self=this;
}

uint32  U7object::number_of_objects(void)
{
  U7file *uf=U7FileManager::get_ptr()->get_file_object(filename);
  if (!uf) return 0;
  return uf->number_of_objects();
}

char* U7object::retrieve(size_t &len)
{
  U7file *uf=U7FileManager::get_ptr()->get_file_object(filename);
  if (!uf) return 0;
  return uf->retrieve(objnumber,len);
}

bool  U7object::retrieve(const char *fname)
{
  FILE *fp=U7open(fname,"wb");

  char  *n;
  size_t  l;

  try
  {
    n = retrieve(l);
  }
  catch( const std::exception & err )
  {
    std::fclose(fp);
    throw (err);
  }
  if (!n) {
    std::fclose(fp);
    return false;
  }
  std::fwrite(n,l,1,fp);  // &&&& Should check return value
  std::fclose(fp);
  delete [] n;
  return true;
}

---