fought with linter

Author: wantonsolutions

example/MessagePack/MessagePackTests.go

@@ -2,6 +2,7 @@ package main
 
 import (
 	"fmt"
+
 	"github.com/DistributedClocks/GoVector/govec/vclock"
 	"github.com/vmihailenco/msgpack"
 )
@@ -15,6 +16,7 @@ type ClockPayload struct {
 var _ msgpack.CustomEncoder = (*ClockPayload)(nil)
 var _ msgpack.CustomDecoder = (*ClockPayload)(nil)
 
+//EncodeMsgpack is a custom encoder function, needed for msgpack interoperability
 func (d *ClockPayload) EncodeMsgpack(enc *msgpack.Encoder) error {
 
 	var err error
@@ -51,6 +53,8 @@ func (d *ClockPayload) EncodeMsgpack(enc *msgpack.Encoder) error {
 
 }
 
+//DecodeMsgpack is a custom decoder function, needed for msgpack
+//interoperability
 func (d *ClockPayload) DecodeMsgpack(dec *msgpack.Decoder) error {
 
 	var err error

govec/govec.go

@@ -1,4 +1,4 @@
-//GoVector vector clock logging library
+//Package govec is a vector clock logging library
 package govec
 
 import (
@@ -76,7 +76,8 @@ type GoLogConfig struct {
 	Priority LogPriority
 }
 
-//Returns the default GoLogConfig with default values for various fields.
+//GetDefaultConfig returns the default GoLogConfig with default values
+//for various fields.
 func GetDefaultConfig() GoLogConfig {
 	config := GoLogConfig{
 		Buffered:      false,
@@ -88,29 +89,29 @@ func GetDefaultConfig() GoLogConfig {
 	return config
 }
 
-//This is the data structure that is actually end on the wire
+//VClockPayload is the data structure that is actually end on the wire
 type VClockPayload struct {
 	Pid     string
 	VcMap   map[string]uint64
 	Payload interface{}
 }
 
-//Prints the Data Stuct as Bytes
+//PrintDataBytes prints the Data Stuct as Bytes
 func (d *VClockPayload) PrintDataBytes() {
 	fmt.Printf("%x \n", d.Pid)
 	fmt.Printf("%X \n", d.VcMap)
 	fmt.Printf("%X \n", d.Payload)
 }
 
-//Prints the Data Struct as a String
+//String returns VClockPayload's pid as a string
 func (d *VClockPayload) String() (s string) {
 	s += "-----DATA START -----\n"
 	s += string(d.Pid[:])
 	s += "-----DATA END -----\n"
 	return
 }
 
-/* Custom encoder function, needed for msgpack interoperability */
+//EncodeMsgpack is a custom encoder function, needed for msgpack interoperability
 func (d *VClockPayload) EncodeMsgpack(enc *msgpack.Encoder) error {
 
 	var err error
@@ -147,7 +148,8 @@ func (d *VClockPayload) EncodeMsgpack(enc *msgpack.Encoder) error {
 
 }
 
-/* Custom decoder function, needed for msgpack interoperability */
+//DecodeMsgpack is a custom decoder function, needed for msgpack
+//interoperability
 func (d *VClockPayload) DecodeMsgpack(dec *msgpack.Decoder) error {
 	var err error
 
@@ -324,7 +326,7 @@ func (gv *GoLog) prepareLogFile() {
 	}
 }
 
-//Returns the current vector clock
+//GetCurrentVC returns the current vector clock
 func (gv *GoLog) GetCurrentVC() vclock.VClock {
 	return gv.currentVC
 }
@@ -347,26 +349,28 @@ func defaultDecoder(buf []byte, payload interface{}) error {
 	return msgpack.Unmarshal(buf, payload)
 }
 
-//Enables buffered writes to the log file. All the log messages are only written
-//to the LogFile via an explicit call to the function Flush.
-//Note: Buffered writes are automatically disabled.
+//EnableBufferedWrites enables buffered writes to the log file. All
+//the log messages are only written to the LogFile via an explicit
+//call to the function Flush.  Note: Buffered writes are automatically
+//disabled.
 func (gv *GoLog) EnableBufferedWrites() {
 	gv.buffered = true
 }
 
-//Disables buffered writes to the log file. All the log messages from now on
-//will be written to the Log file immediately. Writes all the existing
-//log messages that haven't been written to Log file yet.
+//DisableBufferedWrites disables buffered writes to the log file. All
+//the log messages from now on will be written to the Log file
+//immediately. Writes all the existing log messages that haven't been
+//written to Log file yet.
 func (gv *GoLog) DisableBufferedWrites() {
 	gv.buffered = false
 	if gv.output != "" {
 		gv.Flush()
 	}
 }
 
-//Writes the log messages stored in the buffer to the Log File. This
-//function should be used by the application to also force writes in
-//the case of interrupts and crashes.   Note: Calling Flush when
+//Flush writes the log messages stored in the buffer to the Log File.
+//This function should be used by the application to also force writes
+//in the case of interrupts and crashes.   Note: Calling Flush when
 //BufferedWrites is disabled is essentially a no-op.
 func (gv *GoLog) Flush() bool {
 	complete := true
@@ -446,16 +450,17 @@ func (gv *GoLog) tickClock() {
 	gv.currentVC.Tick(gv.pid)
 }
 
-//Increments current vector timestamp and logs it into Log File.
-//* LogMessage (string) : Message to be logged
+//LogLocalEvent Increments current vector timestamp and logs it into
+//Log File.  * LogMessage (string) : Message to be logged
 func (gv *GoLog) LogLocalEvent(Message string) (logSuccess bool) {
 	return gv.LogLocalEventWithPriority(Message, gv.priority)
 }
 
-//If the priority of the logger is lower than or equal to the priority
-//of this event then the current vector timestamp is incremented and the
-//message is logged it into the Log File. A color coded string is also
-//printed on the console.
+//LogLocalEventWithPriority implements LogLocalEvent with priority
+//levels. If the priority of the logger is lower than or equal to the
+//priority of this event then the current vector timestamp is
+//incremented and the message is logged it into the Log File. A color
+//coded string is also printed on the console.
 //* LogMessage (string) : Message to be logged
 //* Priority (LogPriority) : Priority at which the message is to be logged
 func (gv *GoLog) LogLocalEventWithPriority(LogMessage string, Priority LogPriority) (logSuccess bool) {
@@ -470,17 +475,15 @@ func (gv *GoLog) LogLocalEventWithPriority(LogMessage string, Priority LogPriori
 	return
 }
 
-/*
-This function is meant to be used immediately before sending.
-LogMessage will be logged along with the time of the send
-buf is encode-able data (structure or basic type)
-Returned is an encoded byte array with logging information.
-
-This function is meant to be called before sending a packet. Usually,
-it should Update the Vector Clock for its own process, package with
-the clock using gob support and return the new byte array that should
-be sent onwards using the Send Command
-*/
+//PrepareSendWithPriority is meant to be used immediately before sending.
+//LogMessage will be logged along with the time of the send
+//buf is encode-able data (structure or basic type)
+//Returned is an encoded byte array with logging information.
+//
+//This function is meant to be called before sending a packet. Usually,
+//it should Update the Vector Clock for its own process, package with
+//the clock using gob support and return the new byte array that should
+//be sent onwards using the Send Command
 func (gv *GoLog) PrepareSendWithPriority(mesg string, buf interface{}, Priority LogPriority) (encodedBytes []byte) {
 
 	//Converting Vector Clock from Bytes and Updating the gv clock
@@ -505,17 +508,15 @@ func (gv *GoLog) PrepareSendWithPriority(mesg string, buf interface{}, Priority
 	return
 }
 
-/*
-This function is meant to be used immediately before sending.
-LogMessage will be logged along with the time of the send
-buf is encode-able data (structure or basic type)
-Returned is an encoded byte array with logging information.
-
-This function is meant to be called before sending a packet. Usually,
-it should Update the Vector Clock for its own process, package with
-the clock using gob support and return the new byte array that should
-be sent onwards using the Send Command
-*/
+//PrepareSend is meant to be used immediately before sending.
+//LogMessage will be logged along with the time of the send
+//buf is encode-able data (structure or basic type)
+//Returned is an encoded byte array with logging information.
+//
+//This function is meant to be called before sending a packet. Usually,
+//it should Update the Vector Clock for its own process, package with
+//the clock using gob support and return the new byte array that should
+//be sent onwards using the Send Command
 func (gv *GoLog) PrepareSend(mesg string, buf interface{}) []byte {
 	return gv.PrepareSendWithPriority(mesg, buf, gv.priority)
 }
@@ -529,16 +530,14 @@ func (gv *GoLog) mergeIncomingClock(mesg string, e VClockPayload, Priority LogPr
 	gv.logWriteWrapper(mesg, "Something went Wrong, Could not Log!", Priority)
 }
 
-/*
-UnpackReceive is used to unmarshall network data into local structures.
-LogMessage will be logged along with the vector time the receive happened
-buf is the network data, previously packaged by PrepareSend unpack is
-a pointer to a structure, the same as was packed by PrepareSend
-
-This function is meant to be called immediately after receiving
-a packet. It unpacks the data by the program, the vector clock. It
-updates vector clock and logs it. and returns the user data
-*/
+//UnpackReceiveWithPriority is used to unmarshall network data into local structures.
+//LogMessage will be logged along with the vector time the receive happened
+//buf is the network data, previously packaged by PrepareSend unpack is
+//a pointer to a structure, the same as was packed by PrepareSend
+//
+//This function is meant to be called immediately after receiving
+//a packet. It unpacks the data by the program, the vector clock. It
+//updates vector clock and logs it. and returns the user data
 func (gv *GoLog) UnpackReceiveWithPriority(mesg string, buf []byte, unpack interface{}, Priority LogPriority) {
 
 	gv.mutex.Lock()

govec/govec_test.go

@@ -5,7 +5,7 @@ import (
 	//"fmt"
 )
 
-var TestPID string = "TestPID"
+var TestPID = "TestPID"
 
 func TestBasicInit(t *testing.T) {