dmonde/lib/dmF.py

"""fonctions generiques DMonde"""

def classe(txt):
    """retourne une classe a partir d'une string"""
    return getattr(sys.modules[__name__], txt)


def mini(e1, e2):
    """renvoie le plus petit entier"""
    if e1 <= e2:
        retour = e1
    else:
        retour = e2
    return retour

def maxi(e1, e2):
    """renvoie le plus petit entier"""
    if e1 >= e2:
        retour = e1
    else:
        retour = e2
    return retour

def contractTxt(txt, nb = 0):
    """retourne un texte de longueur limitee, 
       de la forme 'abcd...xyz'
       nb doit etre superieur ou egal a 1"""
    if not nb > 0: return txt
    if not nb >= 4: return txt[:nb]
    if not nb >= 10: return "{}...".format(txt[:(nb-3)])
    if len(txt) <= nb: return txt
    t1 = txt[:(nb-6)]
    t2 = txt[-3:]
    return "{}...{}".format(t1, t2)

def inverser(lst):
    """retourne la liste inversee"""
    return list(reversed(lst))

class DmPile(object):
    """pile d'objets ayant des hauteurs differentes
       le dernier objet ajoute est dessus (premier)"""
    def __init__(self):
        self._pile = []

    def __getitem__(self, zCible):
        """renvoie l'objet a l'altitude z"""
        if not zCible >= 0: return None
        z = 0
        for cpl in inverser(self._pile):
            z += cpl[1]
            if z > zCible: return cpl[0]
        return None
    
    def __repr__(self, *args, **kwargs):
        return str(self._pile)
            
    def pile(self):
        """retourne la pile d'objets (sans les hauteurs)"""
        return [cpl[0] for cpl in self._pile]

    def elip(self):
        """retourne la pile (sans les hauteurs) a l'envers (en partant du dessous)"""
        return inverser([cpl[0] for cpl in self._pile])

    def __iter__(self):
        return self.pile().__iter__()
    
    def ajouter(self, objet, h = 1):   
        """ajoute un objet de hauteur h sur la pile""" 
        self._pile.insert(0, (objet,h))

    def vide(self):
        return (len(self._pile) == 0)

    def premier(self):
        if self.vide(): return None
        return self.pile()[0]

    def retirer(self, objet):
        """retire l'objet de la pile"""
        if not objet in self.pile(): 
            print "Impossible trouver l'objet dans la pile, impossible de l'en retirer"
            return
        index = self.pile().index(objet)
        cpl = self._pile[index]
        self._pile.remove(cpl)
        
    def hauteur(self):
        """retourne la hauteur totale de la pile"""
        retour = 0
        for h in [cpl[1] for cpl in self._pile]:
            retour += h
        return retour
    
    def hDe(self, obj):
        """renvoie la hauteur de l'objet demande, None sinon"""
        d = {obj:h for obj, h in self._pile}
        if not obj in d: return None
        return d[obj]

    def zR(self, obj):
        """renvoie l'altitude relative de l'objet demande, None sinon"""
        z = 0
        for o, h in inverser(self._pile):
            if o == obj: return z
            z += h
        return None
            
            
        
# pile = DmPile()
# pile.ajouter("a",10)
# pile.ajouter("b",3)
# pile.ajouter("c",3)
# print pile.zR("b")