C:/Users/albertlr/projects/TarzaNN/TarzaNN/Directory.h

Go to the documentation of this file.

/****************************************************************************
 **
 ** Copyright C 2002-2012 Laboratory for Active and Attentive Vision (LAAV), Department of Computer Science and Engineering, York University, Toronto, ON, Canada.
 ** All rights reserved.
 **
 ** This file is part of the TarzaNN Neural Network Simulator.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** See http://www.tarzann.org/gpl/ for GPL licensing information.
 **
 ** Contact info@tarzann.org if any conditions of this licensing are
 ** not clear to you.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ****************************************************************************/

#ifndef DIRECTORY_H
#define DIRECTORY_H

struct DirectoryEntry {
        char *name;
        int type;
        
        DirectoryEntry() {
                name = NULL;
                type = 0;
        }
        ~DirectoryEntry() {
                delete[] name;
        }
};


class Directory {
public:
        // flags
        static const int F_HIDDEN;  // show hidden files
        
        // types
        static const int T_FILE;    // regular file
        static const int T_DIR;     // a directory
        static const int T_OTHER;   // not a file or a directory
        
        static int pathType(char *path);
        
        Directory(char *path = NULL, int flags = 0);
        ~Directory();
        
        int size();
        
        char *getPath();
        

        bool setPath(char *path);
        
        int getFlags();
        

        bool setFlags(int flags);
        

        char *getName(int i);
        

        char *getFullPath(int i);
        
        int getType(int i);
        
#ifdef _WIN32
#define RECOG_SEP "/\\"
#define USE_SEP '\\'
#else
#define RECOG_SEP "/"  // separators we recognize
#define USE_SEP '/'    // separator we will actually use
#endif
        
        // no allocation
        static char *get_basename(char *path) {
                char *x;
                x = path + strlen(path) - 1;
                // Skip tailing path separators...
                while (x >= path && strchr(RECOG_SEP,*x))
                        x--;
                if (x < path)
                        return path;
                while (x >= path && !strchr(RECOG_SEP,*x))
                        x--;
                if (x < path)
                        return path;
                return x+1;
        }
        
        // allocation
        static char *get_dirname(char *path) {
                char *x, *work;
                x = path + strlen(path) - 1;
                // Remove tailing path separators...
                while (x > path && strchr(RECOG_SEP,*x))
                        x--;
                if (x <= path) {
                        char *p = new char[2];
                        /* "root" directory */
                        p[0] = USE_SEP;
                        p[1] = '\0';
                        return p;
                }
                // Create copy to work with
                work = copystr(path);
                work[x-path+1] = '\0';
                x = work + strlen(work) - 1;
                while (x >= work && !strchr(RECOG_SEP,*x))
                        x--;
                if (x < work) {
                        // no directory
                        delete work;
            const char* s1 = ".";
                        return copystr(s1);
                }
                
                while (x >= work && strchr(RECOG_SEP,*x))
                        x--;
                x++;
                if (x == work) {
                        // root directory
                        delete work;
                        char *p = new char[2];
                        p[0] = USE_SEP;
                        p[1] = '\0';
                        return p;
                } else {
                        *x = '\0';
                        return work;
                }
        }
        
        static int matches_sequence(char *file, char *prefix, char *suffix,
                                                                long *seqno_r) {
                int np = strlen(prefix), ns = strlen(suffix), nf = strlen(file);
                if (nf <= np+ns)
                        return 0; /* file name is too short */
                if (strncmp(file,prefix,np))
                        return 0; /* nope - prefix doesn't match */
                char *x = file + strlen(file) - ns;
                if (strcmp(x,suffix))
                        return 0; /* nope - suffix doesn't match */
                char *buf = new char[x-file-np+1];
                memcpy(buf,file+np,x-file-np);
                buf[x-file-np] = '\0';
                unsigned long seqno;
                char *chk;
                seqno = strtol(buf,&chk,10);
                if (*chk != '\0') {
                        delete[] buf;
                        return 0; /* not a number */
                }
                if (seqno_r)
                        *seqno_r = seqno;
                delete[] buf;
                return 1; /* match */
        }
        static char *copystr(const char *s) {
                if (!s)
                        return NULL;
                char *s2 = new char[strlen(s)+1];
                if (!s2)
                        abort();
                strcpy(s2,s);
                return s2;
        }       
        
private:
        void clear();
        void append(char *name, int type);

#ifdef WIN32
        void fix_dir_separators(char* path);
#endif

        char *path;
        int flags;
        DirectoryEntry *entries;
        int e_spc, e_use;
        
};
#endif /* DIRECTORY_H */