All Downloads are FREE. Search and download functionalities are using the official Maven repository.

src.org.python.modules.posix.PyStatResult Maven / Gradle / Ivy

Go to download

Jython is an implementation of the high-level, dynamic, object-oriented language Python written in 100% Pure Java, and seamlessly integrated with the Java platform. It thus allows you to run Python on any Java platform.

There is a newer version: 2.7.4
Show newest version
/* Copyright (c) Jython Developers */
package org.python.modules.posix;

import jnr.posix.FileStat;

import org.python.core.ArgParser;
import org.python.core.Py;
import org.python.core.PyList;
import org.python.core.PyNewWrapper;
import org.python.core.PyObject;
import org.python.core.PyString;
import org.python.core.PyTuple;
import org.python.core.PyType;
import org.python.core.Visitproc;

import org.python.expose.ExposedGet;
import org.python.expose.ExposedMethod;
import org.python.expose.ExposedNew;
import org.python.expose.ExposedType;
import org.python.expose.MethodType;

import java.nio.file.attribute.DosFileAttributes;
import java.nio.file.attribute.FileTime;
import java.util.Map;
import java.util.concurrent.TimeUnit;

@ExposedType(name = "stat_result", isBaseType = false)
public class PyStatResult extends PyTuple {

    public static final PyType TYPE = PyType.fromClass(PyStatResult.class);

    static {
        // Can only determine the module name during runtime
        TYPE.setName(PosixModule.getOSName() + "." + TYPE.fastGetName());
    }

    @ExposedGet
    public PyObject st_mode, st_ino, st_dev, st_nlink, st_uid, st_gid, st_size, st_atime, st_mtime,
        st_ctime;

    @ExposedGet
    public static final int n_sequence_fields = 10, n_fields = 10, n_unnamed_fields = 10;

    PyStatResult(PyObject... vals) {
        super(TYPE, vals);
        st_mode = vals[0];
        st_ino = vals[1];
        st_dev = vals[2];
        st_nlink = vals[3];
        st_uid = vals[4];
        st_gid = vals[5];
        st_size = vals[6];
        st_atime = vals[7];
        st_mtime = vals[8];
        st_ctime = vals[9];
    }

    @ExposedNew
    static PyObject stat_result_new(PyNewWrapper wrapper, boolean init, PyType subtype,
                                    PyObject[] args, String[] keywords) {
        ArgParser ap = new ArgParser("stat_result", args, keywords, new String[] {"tuple"}, 1);
        PyObject obj = ap.getPyObject(0);
        if (obj instanceof PyTuple) {
            if (obj.__len__() != n_fields) {
                String msg = String.format("stat_result() takes a %s-sequence (%s-sequence given)",
                                           n_fields, obj.__len__());
                throw Py.TypeError(msg);
            }
            // tuples are immutable, so we can just use its underlying array
            return new PyStatResult(((PyTuple)obj).getArray());
        }
        else {
            PyList seq = new PyList(obj);
            if (seq.__len__() != n_fields) {
                String msg = String.format("stat_result() takes a %s-sequence (%s-sequence given)",
                                           n_fields, obj.__len__());
                throw Py.TypeError(msg);
            }
            return new PyStatResult((PyObject[])seq.__tojava__(PyObject[].class));
        }
    }

    // Return a Python stat result from a posix layer FileStat object, a bulk Map retrieval of attributes, or AttributeView.
    public static PyStatResult fromFileStat(FileStat stat) {
        return new PyStatResult(
                Py.newInteger(stat.mode()),
                Py.newInteger(stat.ino()),
                Py.newLong(stat.dev()),
                Py.newInteger(stat.nlink()),
                Py.newInteger(stat.uid()),
                Py.newInteger(stat.gid()),
                Py.newInteger(stat.st_size()),
                Py.newFloat(stat.atime()),
                Py.newFloat(stat.mtime()),
                Py.newFloat(stat.ctime()));
    }

    private static double fromFileTime(FileTime fileTime) {
        return fileTime.to(TimeUnit.NANOSECONDS) / 1e9;
    }

    private static Long zeroOrValue(Long value) {
        if (value == null) {
            return new Long(0L);
        } else {
            return value;
        }
    }

    private static Integer zeroOrValue(Integer value) {
        if (value == null) {
            return new Integer(0);
        } else {
            return value;
        }
    }

    public static PyStatResult fromUnixFileAttributes(Map stat) {

        Integer mode = zeroOrValue((Integer)stat.get("mode"));
        Long ino = zeroOrValue((Long)stat.get("ino"));
        Long dev = zeroOrValue((Long)stat.get("dev"));
        Integer nlink = zeroOrValue((Integer)stat.get("nlink"));
        Integer uid = zeroOrValue((Integer)stat.get("uid"));
        Integer gid = zeroOrValue((Integer)stat.get("gid"));
        Long size = zeroOrValue((Long)stat.get("size"));

        return new PyStatResult(
                Py.newInteger(mode),
                Py.newInteger(ino),
                Py.newLong(dev),
                Py.newInteger(nlink),
                Py.newInteger(uid),
                Py.newInteger(gid),
                Py.newInteger(size),
                Py.newFloat(fromFileTime((FileTime)stat.get("lastAccessTime"))),
                Py.newFloat(fromFileTime((FileTime)stat.get("lastModifiedTime"))),
                Py.newFloat(fromFileTime((FileTime) stat.get("ctime"))));
    }

    public static PyStatResult fromDosFileAttributes(int mode, DosFileAttributes stat) {
        return new PyStatResult(
                Py.newInteger(mode),
                Py.newInteger(0),
                Py.newLong(0),
                Py.newInteger(0),
                Py.newInteger(0),
                Py.newInteger(0),
                Py.newInteger(stat.size()),
                Py.newFloat(fromFileTime(stat.lastAccessTime())),
                Py.newFloat(fromFileTime(stat.lastModifiedTime())),
                Py.newFloat(fromFileTime(stat.creationTime())));
    }

    // Override pyget, getslice to preserve backwards compatiblity that ints are returned for time elements
    // if accessing by an index or slice

    private final static int ST_ATIME = 7;
    private final static int ST_MTIME = 8;
    private final static int ST_CTIME = 9;

    @Override
    public PyObject pyget(int index) {
        if (index == ST_ATIME || index == ST_MTIME || index == ST_CTIME) {
            return super.pyget(index).__int__();
        } else {
            return super.pyget(index);
        }
    }

    @Override
    protected PyObject getslice(int start, int stop, int step) {
        if (step > 0 && stop < start) {
            stop = start;
        }
        int n = sliceLength(start, stop, step);
        PyObject[] newArray = new PyObject[n];
        for (int i = start, j = 0; j < n; i += step, j++) {
            newArray[j] = pyget(i);
        }
        return new PyTuple(newArray, false);
    }

    @Override
    public synchronized PyObject __eq__(PyObject o) {
        return stat_result___eq__(o);
    }

    @ExposedMethod(type = MethodType.BINARY)
    final synchronized PyObject stat_result___eq__(PyObject o) {
        if (getType() != o.getType() && !getType().isSubType(o.getType())) {
            return null;
        }
        int tl = __len__();
        int ol = o.__len__();
        if (tl != ol) {
            return Py.False;
        }
        int i = cmp(this, tl, o, ol);
        return (i < 0) ? Py.True : Py.False;
    }

    @Override
    public synchronized PyObject __ne__(PyObject o) {
        return stat_result___ne__(o);
    }

    @ExposedMethod(type = MethodType.BINARY)
    final synchronized PyObject stat_result___ne__(PyObject o) {
        PyObject eq = stat_result___eq__(o);
        if (eq == null) {
            return null;
        }
        return eq.__not__();
    }

    /**
     * Used for pickling.
     *
     * @return a tuple of (class, tuple)
     */
    @Override
    public PyObject __reduce__() {
        return stat_result___reduce__();
    }

    @ExposedMethod
    final PyObject stat_result___reduce__() {
        PyTuple newargs = __getnewargs__();
        return new PyTuple(getType(), newargs);
    }

    @Override
    public PyTuple __getnewargs__() {
        return new PyTuple(new PyList(getArray()));
    }

    @Override
    public PyString __repr__() {
        return (PyString) Py.newString(
                TYPE.fastGetName() + "(" +
                "st_mode=%r, st_ino=%r, st_dev=%r, st_nlink=%r, st_uid=%r, "+
                "st_gid=%r, st_size=%r, st_atime=%r, st_mtime=%r, st_ctime=%r)").__mod__(this);
    }


    /* Traverseproc implementation */
    @Override
    public int traverse(Visitproc visit, Object arg) {
        int retVal = super.traverse(visit, arg);
        if (retVal != 0) {
            return retVal;
        }
        if (st_mode != null) {
            retVal = visit.visit(st_mode, arg);
            if (retVal != 0) {
                return retVal;
            }
        }
        if (st_ino != null) {
            retVal = visit.visit(st_ino, arg);
            if (retVal != 0) {
                return retVal;
            }
        }
        if (st_dev != null) {
            retVal = visit.visit(st_dev, arg);
            if (retVal != 0) {
                return retVal;
            }
        }
        if (st_nlink != null) {
            retVal = visit.visit(st_nlink, arg);
            if (retVal != 0) {
                return retVal;
            }
        }
        if (st_uid != null) {
            retVal = visit.visit(st_uid, arg);
            if (retVal != 0) {
                return retVal;
            }
        }
        if (st_gid != null) {
            retVal = visit.visit(st_gid, arg);
            if (retVal != 0) {
                return retVal;
            }
        }
        if (st_size != null) {
            retVal = visit.visit(st_size, arg);
            if (retVal != 0) {
                return retVal;
            }
        }
        if (st_atime != null) {
            retVal = visit.visit(st_atime, arg);
            if (retVal != 0) {
                return retVal;
            }
        }
        if (st_mtime != null) {
            retVal = visit.visit(st_mtime, arg);
            if (retVal != 0) {
                return retVal;
            }
        }
        return st_ctime != null ? visit.visit(st_ctime, arg) : 0;
    }

    @Override
    public boolean refersDirectlyTo(PyObject ob) {
        return ob != null && (ob == st_mode || ob == st_ino || ob == st_dev || ob == st_nlink
            || ob == st_uid || ob == st_gid || ob == st_size || ob == st_atime
            || ob == st_mtime || ob == st_ctime || super.refersDirectlyTo(ob));
    }
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy