Misc.h

Go to the documentation of this file.

#ifndef MISC_H
#define MISC_H
/*
 * ALMA - Atacama Large Millimeter Array
 * (c) European Southern Observatory, 2002
 * (c) Associated Universities Inc., 2002
 * Copyright by ESO (in the framework of the ALMA collaboration),
 * Copyright by AUI (in the framework of the ALMA collaboration),
 * All rights reserved.
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free software Foundation; either
 * version 2.1 of the License, or (at your option) any later verson.
 * 
 * This library 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
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307  USA
 *
 *
 * File Misc.h
 */

#include <iostream>
#include <fstream>
#include <string> 
#include <vector>
#include <set>
#include <map>

#ifndef WITHOUT_BOOST
#include <boost/filesystem/path.hpp>
#include <boost/filesystem/convenience.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/split.hpp>
#else
#include <sys/stat.h>
#include <sstream>
#endif

#include <algorithm>
#include <cctype>
#include <locale>

typedef unsigned char xmlChar;

struct _xmlNode;
typedef struct _xmlNode xmlNode;
typedef xmlNode *xmlNodePtr;

struct _xmlDoc;
typedef struct _xmlDoc xmlDoc;
typedef xmlDoc *xmlDocPtr;

struct _xsltStylesheet;
typedef struct _xsltStylesheet xsltStylesheet;
typedef xsltStylesheet *xsltStylesheetPtr;

extern "C" int xmlLoadExtDtdDefaultValue;

namespace asdm {
  bool directoryExists(const char* dir);
        
  bool createDirectory(const char* dir);
        
  bool createPath(const char* path);
        
        
#define ByteSwap5(x) ByteSwap((unsigned char *) &x,sizeof(x))    
  void ByteSwap(unsigned char * b, int n);

  class ByteOrder {
  public:
    static const ByteOrder* Little_Endian; /*< A unique object to represent a little endian byte order. */
    static const ByteOrder* Big_Endian;    /*< A unique object to represent a big endian byte order. */
    static const ByteOrder* Machine_Endianity; /*< A unique object storing the endianity of the machine. */

    std::string toString() const ;

    static const ByteOrder* fromString(const std::string & s);

  private:
    std::string name_;

    ByteOrder(const std::string & name);
    virtual ~ByteOrder();
    static const ByteOrder* machineEndianity(); 
  };

  std::string uniqSlashes(const std::string& s);


#ifdef WITHOUT_BOOST
  // string trimming functions to be used in place of boost functions
  // uses lambdas (c++11)

  // trim from start (in place)
  inline void ltrim(std::string &s) {
    s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](int ch) {
          return !std::isspace(ch);
        }));
  }

  // trim from end (in place)
  inline void rtrim(std::string &s) {
    s.erase(std::find_if(s.rbegin(), s.rend(), [](int ch) {
          return !std::isspace(ch);
        }).base(), s.end());
  }

  // trim from both ends (in place)
  inline void trim(std::string &s) {
    ltrim(s);
    rtrim(s);
  }

  // trim from start (copying)
  inline std::string ltrim_copy(std::string s) {
    ltrim(s);
    return s;
  }

  // trim from end (copying)
  inline std::string rtrim_copy(std::string s) {
    rtrim(s);
    return s;
  }

  // trim from both ends (copying)
  inline std::string trim_copy(std::string s) {
    trim(s);
    return s;
  }

  // return a copy of str with everything transformed to upper case
  inline std::string str_toupper(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::toupper(c); });
    return s;
  }

  // return a copy of str with everything transformed to lower case
  inline std::string str_tolower(std::string s) {
    std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) { return std::tolower(c); });
    return s;
  }

  // split a string into vector using provided character as the delimiter
  // resuls are added to the pre-existing results vector
  inline void strsplit(const std::string &str, char delim, std::vector<std::string> &result) {
    std::stringstream ss(str);
    std::string token;
    while(std::getline(ss,token,delim)) {
      result.push_back(token);
    }
  }

  // check to see if a file exists using posix 'stat(...)'
  inline bool file_exists(const std::string &filename) {
    struct stat statbuf;
    return (stat(filename.c_str(),&statbuf)==0);
  }

#endif

  class ASDMUtilsException {
  public:
    ASDMUtilsException();
    ASDMUtilsException(const std::string& message);
    
    const std::string& getMessage();
    
  private:
    std::string message;
  };
  
  class ASDMUtils {
  public :
    enum Origin { UNKNOWN, ALMA, EVLA };
    static std::string          version (const std::string& asdmPath);
    static std::vector<std::string> telescopeNames(const std::string& asdmPath);
    static Origin               origin(const std::vector<std::string>& telescopeNames);
    static std::vector<std::string> xmlFilenames(const std::string& asdmPath);
    
    static std::string pathToV2V3ALMAxslTransform() ;
    static std::string pathToV2V3EVLAxslTransform() ;
    static std::string nameOfV2V3xslTransform(ASDMUtils::Origin origin);

#ifndef WITHOUT_BOOST
    struct DotXMLFilter {
    public:
      DotXMLFilter(std::vector<std::string>& filenames);
      //void operator() (path& p);
      void operator() ( boost::filesystem::directory_entry& p);
    private:
      std::vector<std::string>* filenames;    
    };
#endif
    
  private :
    static bool initialize();
    static bool initialized;
    static bool hasChild(xmlDocPtr, xmlNodePtr node, const xmlChar* childName);
    static std::string parseRow(xmlDocPtr, xmlNodePtr node, const xmlChar* childName);
    static std::set<std::string> evlaValidNames;
    static std::set<std::string> almaValidNames;
    static std::map<ASDMUtils::Origin, std::string> filenameOfV2V3xslTransform;
    static std::map<std::string, std::string> rootSubdir ;

    static std::string pathToxslTransform( const std::string& xsltFilename);
  }; // end class ASDMUtil.


  class ASDMParseOptions {
    friend class ASDM;

  public:
    ASDMParseOptions();

    ASDMParseOptions(const ASDMParseOptions& x);

    virtual ~ASDMParseOptions();

    ASDMParseOptions & operator=(const ASDMParseOptions & rhs);

    
    ASDMParseOptions& asALMA();

    ASDMParseOptions& asIRAM_PDB();

    ASDMParseOptions& asEVLA();

    ASDMParseOptions& asV2();

    ASDMParseOptions& asV3();

    ASDMParseOptions& loadTablesOnDemand(bool b);

    ASDMParseOptions& checkRowUniqueness(bool b);

    friend std::ostream& operator<<(std::ostream& output, const ASDMParseOptions& p);

    std::string toString() const;

  private:
    ASDMUtils::Origin   origin_;
    bool                detectOrigin_;
    std::string         version_;
    bool                detectVersion_;
    bool                loadTablesOnDemand_;
    bool                checkRowUniqueness_;
  };                            // end class ASDMParseOptions.

  class XSLTransformerException {

  public:
    XSLTransformerException();

    XSLTransformerException(const std::string & m);
    
    virtual ~XSLTransformerException();

    std::string getMessage() const;

  protected:
    std::string message;

  };

  inline XSLTransformerException::XSLTransformerException() : message ("XSLTransformerException") {}
  inline XSLTransformerException::XSLTransformerException(const std::string& m) : message(m) {}
  inline XSLTransformerException::~XSLTransformerException() {}
  inline std::string XSLTransformerException::getMessage() const {
    return "XSLTransformerException : " + message;
  }

  class XSLTransformer {
  public:
    XSLTransformer();

    virtual ~XSLTransformer();

    XSLTransformer(const std::string& xsltPath);

    void setTransformation(const std::string& xsltPath);

    std::string operator()(const std::string& xmlPath);
    
  private:
    
    xsltStylesheetPtr cur;

    XSLTransformer& operator=(const XSLTransformer & rhs);
    XSLTransformer(const XSLTransformer & rsh);    
  }; // end class XSLTransformer.


  class CharComparator {
  public:
    CharComparator(std::ifstream * is_p = NULL, off_t limit = 0);
    bool operator() (char cl, char cr);

  private:
    std::ifstream* is_p;
    off_t limit;
    char* asdmDebug_p; 
  };

  class CharCompAccumulator {
  private:
    std::string*    accumulator_p;
    std::ifstream*  is_p;
    off_t           limit;
    int             nEqualChars;
    char*           asdmDebug_p; 
  public:
    CharCompAccumulator(std::string* accumulator_p = NULL, std::ifstream * is_p = NULL , off_t limit = 0);

    bool operator()(char cl, char cr);
  };
} // end namespace asdm
#endif  // MISC_H