GBSIOHelper.py

Go to the documentation of this file.

import re
import pickle

from GBSLogger import Log, logger 

class GBSIOHelper :
    """I/O Helper class"""

    def __init__(self,file_name,mode):
        self.__file  = None
        self.__mode  = mode
        self.__ClearCache()
        if mode != "r" and mode != "w":
            print "GBSIOHelper: Bad I/O mode " + str(mode)  + " on " + str(file_name)
            raise IOError
        self.__file = open(file_name,mode)

    def __call__(self,name,type,value=""): return self.DoIO(name,type,value)


    def DoIO(self,name,type,value=""):
        if self.__file == None: raise IOError
        if type != "s" and type != "i" and type != "f" and type != "p":
            Log(self,logger.ERROR,"GBSIOHelper: Bad I/O type " + str(type) + " on " + str(self.__file))
            raise IOError

        #  Check for schema evolution tags '+' and '-'
        schema_tag = ""
        mo = re.search(r"^(\+|-)(.*)",name)
        if mo: (schema_tag,name) = mo.groups()

        ###   Reading   ###
        
        if self.__mode == "r":
            self.__ReadItem()

            # Deal with matching names but tolerate case differences.
            if name.lower() == self.__name.lower():
                if type != self.__type:
                    Log(self,logger.ERROR,"GBSIOHelper: Type mismatch on name: '" + str(name)\
                    + "', found type '" + str(self.__type) + "' but expecting type '"\
                    + str(type) + "' in " + str(self.__file))
                    raise IOError
                value = self.__value
                self.__ClearCache()
                return value

            # Mismatch is O.K. if schema evolution is active
            if schema_tag: return value
            Log(self,logger.ERROR,"GBSIOHelper: Found name: '" + str(self.__name) + "', but expecting '"\
                + str(name) + "' on " + str(self.__file))
            raise IOError

        ###   Writing   ###
        
        else:

            # Schema evolution: don't write dropped names
            if schema_tag == "-": return value
            return self.__WriteItem(name,type,value)

    def Close(self):

        """If reading, check that all the data has been read."""
        if self.__mode == "r":
            line = self.__file.readline()
            if line:
                Log(self,logger.ERROR,"GBSIOHelper: File " + str(self.__file)\
                    + " has extra data:-\n" + str(line) + " after I/O complete.'")
                raise IOError
        self.__file.close()

        
    ######  Private Methods (not user callable)  ######

    def __ClearCache(self):

        """Clear internally cached value (only used for reading)."""
        
        self.__name  = None
        self.__type  = None
        self.__value = None

    def __ReadItem(self):

        """Read item if not already in cache."""
        if self.__name: return

        line = self.__file.readline()
        if not line:
            Log(self,logger.ERROR,"GBSIOHelper: EOF on " + str(self.__file))
            raise IOError
        mo = re.search(r"(.)\s*(.*?):\s+(.*)",line)
        if not mo:
            Log(self,logger.ERROR,"GBSIOHelper: Malformed data:" + str(line)\
                + " on " + str(self.__file))
            raise IOError
        (self.__type,self.__name,self.__value) = mo.groups()
        if   self.__type == "s": pass
        elif self.__type == "i": self.__value = int(self.__value)
        elif self.__type == "f": self.__value = float(self.__value)
        elif self.__type == "p":
            self.__value = pickle.load(self.__file)
            self.__file.readline()
        else:
            Log(self,logger.ERROR,"GBSIOHelper: Bad type: '" + str(self.__type) + "' reading line:" + str(line)\
                + " on " + str(self.__file))
            raise IOError
    

    def __WriteItem(self,name,type,value):

        """Write item to file."""

        self.__file.write(type + name.rjust(30) + ":   ")
        if   type != "p":
            # For strings, replace any '\n' by ' ' before storing
            if   type == "s":
                p = re.compile('(\n)')
                value = p.sub(' ',value)
            self.__file.write(str(value) + "\n")
        else:
            self.__file.write("\n")
            pickle.dump(value,self.__file)
            self.__file.write("\n")
        return value

            



def TestIOHelper():
    ioh = GBSIOHelper("TestIOHelper.state","w")
    ioh("A String","s","This is a string")
    ioh.DoIO("An integer","i",42)
    ioh.DoIO("A floating point","f",3.14159)
    ioh.DoIO("A list","p",["abc",123,456.0])
    ioh.DoIO("A tuple","p",("xyz",111,222.0))
    ioh.DoIO("A second list","p",["abc",123,456.0])
    ioh.DoIO("A second tuple","p",("xyz",111,222.0))
    ioh.Close()
    del ioh
    ioh = GBSIOHelper("TestIOHelper.state","r")

    value = ioh("A String","s")
    print value
    value = ioh.DoIO("An integer","i")
    print value
    value = ioh.DoIO("A floating point","f")
    print value
    value =  ioh.DoIO("A list","p")
    print value
    value =  ioh.DoIO("A tuple","p")
    print value
    value =  ioh.DoIO("A second list","p")
    print value
    value =  ioh.DoIO("A second tuple","p")
    print value
    ioh.Close()
    del ioh

    
    
           
           
           
            

---