Commits

Anonymous committed 4cc473d

Remove trailing underscore from event_ and put_ methods.

Comments (0)

Files changed (2)

             val mutable archivers_: 'archiver list
             val mutable limit_: Priority.t            
 
-            method virtual private event_: 'level -> string -> 'event
+            method private virtual event: 'level -> string -> 'event
 
             method setlimit: 'level -> unit
             method enabled: 'level -> bool
             
-            method private put_:
+            method private put:
                 'a 'b. 'level -> ('event -> 'b) ->
                 ('a, unit, string, 'b) format4 -> 'a
         end
             val mutable archivers_: 'archiver list = archivers
             val mutable limit_ = prioritizer#code limit
         
-            method virtual private event_: 'level -> string -> 'event
+            method private virtual event: 'level -> string -> 'event
 
             method setlimit limit = limit_ <- prioritizer#code limit
             method enabled limit = prioritizer#code limit >= limit_
             
-            method private put_:
+            method private put:
                 'a 'b. 'level -> ('event -> 'b) ->
                 ('a, unit, string, 'b) format4 -> 'a
                 = fun level cont ->
                     let f message =
-                        let e = self#event_ level message in
+                        let e = self#event level message in
                         if self#enabled level then
                             List.iter (fun j -> j#emit e) archivers_;
                         cont e
         inherit ['archiver] Basic.agent prioritizer limit archivers
 
         method invalid: 'a 'b. ('a, unit, string, 'b) format4 -> 'a =
-            self#put_ `Invalid (fun x -> invalid_arg x#message)
+            self#put `Invalid (fun x -> invalid_arg x#message)
 
         method fail: 'a 'b. ('a, unit, string, 'b) format4 -> 'a =
-            self#put_ `Fail (fun x -> failwith x#message)
+            self#put `Fail (fun x -> failwith x#message)
         
         method error: 'a. ('a, unit, string, unit) format4 -> 'a =
-            self#put_ `Error ignore
+            self#put `Error ignore
         
         method warn: 'a. ('a, unit, string, unit) format4 -> 'a =
-            self#put_ `Warn ignore
+            self#put `Warn ignore
         
         method info: 'a. ('a, unit, string, unit) format4 -> 'a =
-            self#put_ `Info ignore
+            self#put `Info ignore
         
         method debug: 'a. ('a, unit, string, bool) format4 -> 'a =
-            self#put_ `Debug (fun _ -> true)
+            self#put `Debug (fun _ -> true)
     end
 
 let basic_prioritizer = new basic_prioritizer
         inherit [Basic.level_t Basic.event basic_channel_archiver] basic_agent
             basic_prioritizer `Warn [archiver]
         
-        method private event_ = new Basic.event basic_prioritizer
+        method private event = new Basic.event basic_prioritizer
     end
 
 let stdout = new basic_stdio_agent basic_stdout_archiver

cf/cf_journal.mli

             *)
             val mutable limit_: Priority.t            
 
-            (** Define the private [event_] method to construct an event object
+            (** Define the private [event] method to construct an event object
                 with a priority level and a message text.
             *)
-            method virtual private event_: 'level -> string -> 'event
+            method private virtual event: 'level -> string -> 'event
 
             (** Use [a#setlimit v] to set the minimum priority code to the
                 code corresponding to the priority level [v].
             
             (** Use this method in level-specific methods of the derived class
                 for constructing events and putting them to archivers.  Use
-                [super#put_ v c] to construct a function that takes a format
+                [super#put v c] to construct a function that takes a format
                 string (and arguments thereby specified) and, if [self#enabled
-                v] returns [true] then calls [self#event_ v m] (where [m] is
+                v] returns [true] then calls [self#event v m] (where [m] is
                 the message text given to the continuation provided to
                 [Printf.kprintf]), iterates on [archivers_] invoking the
                 [emit] method for each one with the constructed event, and
                 returned by [c] is returned by the method when invoked with
                 a format string (and associated arguments).
             *)
-            method private put_:
+            method private put:
                 'a 'b. 'level -> ('event -> 'b) ->
                 ('a, unit, string, 'b) format4 -> 'a
         end