FileDescriptor.hpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2001, 2002, 2003 Stéphane Del Pino

//  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, 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.  

//  $Id: FileDescriptor.hpp,v 1.8 2007/11/21 07:46:13 delpinux Exp $

#ifndef FILE_DESCRIPTOR_HPP
#define FILE_DESCRIPTOR_HPP

#include <ErrorHandler.hpp>
#include <StreamCenter.hpp>

#include <cstring>

class FileDescriptor
{
public:
  enum FormatType {
    am_fmt,
    gmsh,
    mesh,
    medit,
    raw,
    vtk
  };

  enum FileType {
    binary,                     
    dos,                        
    formatDefault,              
    mac,                        
    unices                      
  };

  static FileDescriptor::FormatType
  formatType(const char* c)
  {
    if (std::strcmp(c,"gmsh") == 0) {
      return FileDescriptor::gmsh;
    }
    if (std::strcmp(c,"mesh") == 0) {
      return FileDescriptor::mesh;
    }
    if (std::strcmp(c,"medit") == 0) {
      return FileDescriptor::medit;
    }
    if (std::strcmp(c,"opendx") == 0) {
      fferr(1) << "warning: \"opendx\" is deprecated, use \"raw\" keyword instead\n";
      return FileDescriptor::raw;
    }
    if (std::strcmp(c,"raw") == 0) {
      return FileDescriptor::raw;
    }
    if (std::strcmp(c,"vtk") == 0) {
      return FileDescriptor::vtk;
    }
    if (std::strcmp(c,"am_fmt") == 0) {
      return FileDescriptor::am_fmt;
    }

    throw ErrorHandler(__FILE__,__LINE__,
                       "Unknown File Type: '"+std::string(c)+"'",
                       ErrorHandler::unexpected);
    return FileDescriptor::raw;
  }

  static FileDescriptor::FileType
  fileType(const char* c)
  {
    if (std::strcmp(c,"unix") == 0) {
      return FileDescriptor::unices;
    }
    if (std::strcmp(c,"dos") == 0) {
      return FileDescriptor::dos;
    }
    if (std::strcmp(c,"mac") == 0) {
      return FileDescriptor::mac;
    }
    if (std::strcmp(c,"binary") == 0) {
      return FileDescriptor::binary;
    }
    throw ErrorHandler(__FILE__,__LINE__,
                       "unknown file type",
                       ErrorHandler::unexpected);
    return FileDescriptor::unices;
  }

private:
  const FileDescriptor::FormatType
  __formatType;                 
  const FileDescriptor::FileType
  __fileType;                   
public:
  const FileDescriptor::FormatType&
  format() const
  {
    return __formatType;
  }

  const FileDescriptor::FileType&
  type() const
  {
    return __fileType;
  }

  const std::string
  cr() const
  {
    std::string CR;

    switch (__fileType) {
    case FileDescriptor::binary:
    case FileDescriptor::formatDefault:
    case FileDescriptor::unices: {
      CR = '\n';
      break;
    }
    case FileDescriptor::dos: {
#ifndef __MINGW32__
      CR = "\r\n";
#else // __MINGW32__
      CR = "\n";
#endif // __MINGW32__
      break;
    }
    case FileDescriptor::mac: {
      CR = '\r';
      break;
    }
    default: {
      throw ErrorHandler(__FILE__,__LINE__,
                         "unknown file type",
                         ErrorHandler::unexpected);
    }
    }
    return CR;
  }

  std::string formatName() const 
  {
    switch (__formatType) {
    case am_fmt:
      return "am_fmt";
    case gmsh:
      return "gmsh";
    case mesh:
      return "mesh";
    case medit:
      return "medit";
    case raw:
      return "raw";
    case vtk:
      return "vtk";
    default:
      throw ErrorHandler(__FILE__,__LINE__,
                         "unknown file format",
                         ErrorHandler::unexpected);
      return "error";
    }
  }

  std::string fileTypeName() const 
  {
    switch (__fileType) {
    case binary: {
      return "binary";
    }
    case dos: {
      return "dos";
    }
    case formatDefault: {
      return "unspecified";
    }
    case mac: {
      return "mac";
    }
    case unices: {
      return "unix";
    }
    default: {
      throw ErrorHandler(__FILE__,__LINE__,
                         "unknown file type",
                         ErrorHandler::unexpected);
      return "error";
    }
    }
  }

  FileDescriptor(const FileDescriptor::FormatType& format,
                 const FileDescriptor::FileType& type)
    : __formatType(format),
      __fileType(type)
  {
    ;
  }

  FileDescriptor(const FileDescriptor& f)
    : __formatType(f.__formatType),
      __fileType(f.__fileType)
  {
    ;
  }

  ~FileDescriptor()
  {
    ;
  }
};

#endif // FILE_DESCRIPTOR_HPP

---