syntax: 'meth' -> 'fun', 'attr' -> 'var'

[nit.git] / tests / example_objet.nit

# This file is part of NIT ( http://www.nitlanguage.org ).
#
# Copyright 2004-2008 Jean Privat <jean@pryen.org>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# Exemple commenté d'un programme en NIT
# Cet exemple est tiré du dernier TP C++ de l'année des IUP1

# Attention, NIT est un langage enrichi en sucre (syntaxique) et en déclaration 
# implicite. Cet exemple en introduit petit à petit. Et chaque utilisation est 
# abondamment commentée. D'ailleurs, a propos de commentaires, il est peut-être
# trop tard pour dire que ceux-ci commencent par un dièse (#)

# Les points suivants sont couverts par cet exemple :
# - définition des modules
# - définition des classes
# - définition des propriétés (attributs, procédures, fonctions)
# - structures de contrôles (blocs, boucles, conditions)
# - variables locales
# - accesseurs universels
# - constructeurs et constructions d'instances
# - chaînes de caractères

# Les points suivants sont aperçus :
# - classes génériques
# - protection (visibilité des propriétés)
# - collections
# - héritage et redéfinition

# Les points suivants ne sont pas abordés :
# - accesseurs implicites
# - (re)définition des opérateurs
# - paramètres implicites
# - méthodes à arité variable
# - méthodes retardées (virtuelles pures)
# - constructeurs universels
# - appel à super
# - héritage multiple
# - covariance des types
# - raffinement de classes

# Un fichier = un module. Les classes d'un module sont définies dans le fichier.
# Au début des fichiers, les modules à importer doivent être déclarés (via le
# mot clé "import"). Implicitement, tout module importe le module nommé
# "standard" qui définit les classes usuelles.

# On va étudier une représentation d'un entrepôt de produits variés.
class Entrepot
private
# Dans un bloc "private", les propriétés déclarées sont seulement accessibles au
# receveur ("self")

# Les attributs sont déclarés par le mot clé "fun" et commencent par un "@"
        var _nom_: String               # Un entrepôt a un nom (de type chaîne).
        var _rayons: Array[Rayon]       # Il est composé d'un ensemble de rayon.
        # "Array" est une classe paramétrée, les crochets en sont la marque.
        # La classe "Rayon" est définie plus loin


# Les propriétés déclarées dans un bloc "public" sont accessibles à tout le
# monde.

# Les méthodes (fonctions et procédures) sont déclarées par le mot clé "fun"
        # nom est une fonction qui retourne une chaîne
        fun nom: String
        do
                # "return" sort de la fonction
                return _nom_
                # En fait, les attributs et les méthodes sont dans deux espaces
                # de noms distincts.
                # Le @ peut se prononcer "at" ce qui rappelle le mot attribut
        end
        
        # set_nom est une procédure qui prend une chaîne en paramètre
        fun set_nom(n: String)
        do
                _nom_ = n               # "=" désigne l'affectation
                # Les affectations sont des instructions et ne sont pas
                # chaînées
        end

        fun add_rayon(r: Rayon)
        do
                _rayons.add(r)          # "add" ajoute un élément
        end

        # to_s est la méthode implicitement appelée par "print" et "println"
        # Il s'agit de la représentation "humaine" d'un objet
        redef fun to_s: String
        do
                # Les variables sont déclarées par "var", leur portée va de leur
                # déclaration jusqu'au "end" correspondant
                var s = new Buffer              # Là où on calcule le résultat
                # Les chaînes littérales sont déclarées avec des guillemets
                s.append("*** Entrepôt ")       # On initialise "s"
                # puis on concatène des chaînes à "s"
                s.append(_nom_)         # la méthode "append" concatène
                s.append(" ***\n")
                # Les conditions sont de la forme "if then else if else end"
                if _rayons.is_empty then
                        s.append("L'entrepôt est vide\n")
                else
                        var i: Iterator[Rayon]  
                        # Les itérateurs permettent de traverser les collections
                        i = _rayons.iterator # "iterator" retourne un nouvel itérateur 
                        # La forme des boucles est "while do end"       
                        while i.is_ok do        # on pointe un élément valide ? 
                                # "item" retourne l'élément pointé par
                                # un iterateur
                                s.append(i.item.to_s)
                                i.next  # passe à l'élément suivant
                        end
                        s.add('\n')     # "add" ajoute un caractère à la fin.
                        # Comme en C, les caractères sont entre simples cotes.
                end
                return s.to_s
        end


# Dans un bloc "constructor", les méthodes déclarées sont celles utilisées pour
# créer des instances

        # init sans paramètre est le constructeur implicite
        init
        do
                _nom_ = "sans nom"
                # "new" permet d'instancier une classe. 
                _rayons = new Array[Rayon]
                # Un nouveau tableau est implicitement vide
                # On aurait pu prévoir une capacité en utilisant un autre
                # constructeur et en écrivant :
                #       _rayons = new Array[Rayon].with_capacity(50)
        end
        
        # Plusieurs constructeurs peuvent être définis
        init with_nom(n: String)
        do
                _nom_ = n
                _rayons = new Array[Rayon]
        end

# Une classe qui ne possède pas de méthode définie dans un bloc "constructor"
# est une classe abstraite : elle ne peut être instanciée.
end

class Produit
private
        var _nom_: String               # Désignation du produit
        var _qte_: Int                  # Quantité en stock



        # Comme nous l'avons vu, les accesseurs en lecture sont
        # généralement homonymes aux attributs (au @ près).
        fun nom: String
        do
                return _nom_
        end

        fun qte: Int
        do
                return _qte_
        end

        # Toutefois, pour les accesseurs en écriture, il est d'usage en NIT 
        # d'utiliser un type de méthode particulier appelé "accesseur universel"
        # son nom se caractérise par un "=" final
        fun qte=(i: Int)
        do
                _qte_ = i
        end
        # La méthode s'utilise alors de façon élégante :
        # pour p de type statique Produit, l'expression
        #       p.qte
        # correspond à un envoi de message vers la fonction "qte" et retourne
        # la quantité d'un produit. Tandis que l'instruction
        #       p.qte = 16
        # correspond à un envoi de message vers la méthode "qte=" et affecte
        # la quantité d'un produit.


        redef fun to_s: String
        do
                # On peut aussi utiliser "+" pour concaténer les chaînes
                return _nom_ + ":" + _qte_.to_s
                # Mais ce n'est pas très efficace car cela crée des objets
                # intermédiaires.
        end


        init(nom: String, qte: Int)
        do
                _nom_ = nom
                _qte_ = qte
        end
end

class Rayon
private
        var _stock: Array[Produit]              # Des produits en stock
        var _rubrique: String                   # La catégorie des produits stockés

        # Cette fonction est utilisé par to_s pour afficher un petit titre
        fun to_s_head: String
        do
                # Les déclarations de type sont optionnelles dans un bloc "var".
                # Si une expression est passée comme valeur initiale d'une
                # variable, le type statique de la variable est implicitement
                # celui de l'expression.
                var s = new Buffer
                s.append("* Rayon : ")
                # Ici, le type statique de s est implicitement String

                s.append(_rubrique)
                s.add('\n')
                return s.to_s
        end

        fun cherche_produit(n: String): nullable Produit
        do
                var i = _stock.iterator
                while i.is_ok do
                        var p = i.item
                        # "=" est l'opérateur égalité de valeur.
                        if p.nom == n then
                                return p
                        end
                        i.next
                end
                # "null" correspond à l'objet vide
                return null
        end


        redef fun to_s: String
        do
                var s = new Buffer
                s.append(to_s_head)
                # Les boucles en NIT sont des structures puissantes, toutefois
                # la manipulation des itérateurs peut être facilité par la
                # structure "for in"
                for p in _stock do
                # L'expression de droite doit être sous-type de Collection
                # (ce qui est le cas pour Array[Produit]).
                # La variable p est automatiquement déclarée, son type 
                # automatiquement déduit (ici Produit) et la collection est 
                # automatiquement parcourue
                # En réalité, la structure "for in" n'est que du sucre
                # syntaxique pour une boucle sur une collection via des
                # itérateur comme celle écrite dans la fonction
                # "cherche_produit" précédente
                        s.append(p.to_s)
                        s.add('\n')
                end
                return s.to_s
        end


        # Cette fonction permet de retourner la quantité d'un produit donné
        # Ce service est très simple à implémenter si on utilise cherche_produit
        fun quantite(n: String): Int
        do
                var p = cherche_produit(n)
                # "==" est l'opérateur d'égalité d'identité
                if p == null then
                        return 0
                else
                        return p.qte
                end
        end

        # Le service dual consiste à définir la quantité d'un produit
        # En NIT, il est d'usage de définir ce genre de service par un accesseur
        # universel :
        fun quantite=(n: String, i: Int)
        do
                var p = cherche_produit(n)
                if p == null then
                        # On Construit un nouveau produit que l'on ajoute
                        _stock.add(new Produit(n, i))
                else
                        # On change la quantité du produit trouvé 
                        p.qte = i
                end
        end
        # Les accesseurs universels s'utilise de façon toujours aussi élégante.
        # Pour r de type Rayon, on écrira donc :
        #       r.quantite("clous")
        # pour obtenir la quantité de clous dans le rayon, et :
        #       r.quantite("clous") = 15
        # pour mettre le nombre de clous à 15

        init do end
end

class RayonNormal
special Rayon

        init(r: String)
        do
                _rubrique = r
                _stock = new Array[Produit]
        end
end

class RayonFroid
# Les super-classes sont déclarés avec le mot clé "special".
# Implicitement, c'est "Object", la classe de tous les objets.
special Rayon

# Tant qu'on parle d'implicite, en l'absence de bloc de propriétés,
# celles-ci sont déclarées en tant que "public"
        fun temp_max: Int
        do
                return _temp_max_       # Attribut défini juste en dessous
        end

        var _temp_max_: Int             # Une température maximale
        # Les autres attributs sont bien sûr hérités !

        redef fun to_s_head: String             # On redéfinit cette méthode
        do
        # nous avons vu le "append" et le "+" sur les chaînes, mais la
        # méthode la plus simple reste la construction "{}" qui
        # permet l'inclusion automatique d'expressions. C'est aussi la méthode
        # la plus efficace.
        return "* Rayon Réfrigéré : {_rubrique} - t° max : {_temp_max_}\n"
        end


        init(r: String, t: Int)
        do
                _temp_max_ = t
                _rubrique = r
                _stock = new Array[Produit]
        end
end



# Le main (point d'entrée du programme) peut être déclaré directement à la fin
# des définitions de classes

# Constructeur implicite ("init")
var e = new Entrepot
# "println" affiche un truc et ajoute un \n à la fin
print(e.nom)                    # affiche "sans nom"
# "print" affiche un truc mais sans le \n à la fin                      
printn('\n')                    # va à la de ligne

e.set_nom("Montpellier")
printn(e.nom, "\n\n")                   
# Affiche "Montpellier" et saute une ligne.
# Contrairement à "println", "print" peut prendre plusieurs paramètres

# Constructeur explicite ("with_nom")
e = new Entrepot.with_nom("Lunel")      # on perd l'ancien entrepôt
printn(e, '\n')
# affiche "*** Entrepot Lunel *** L'entrepôt est vide"

var p = new Produit("Carotte", 15)
print(p)                                # affiche Carotte:15
p.qte = 20
print(p)                                # affiche Carotte:20
printn('\n')

var r = new RayonNormal("Légumes")
printn(r, '\n')

r.quantite("Carotte") = 15
r.quantite("Navet") = 10
r.quantite("Chou") = 3
printn(r)
r.quantite("Chou") = 13
r.quantite("Courge") = 1
printn(r, '\n')

e.add_rayon(r)

var r2 = new RayonFroid("Surgelés", -5)
e.add_rayon(r2)
r2.quantite("Pizza") =  12
r2.quantite("Poisson pané") = 4
printn(e)