architecture.puml

@startuml
namespace law {
    interface Callback  {
        + OnWriteFailed(content []byte, reason error)

    }
    class Config << (S,Aquamarine) >> {
        + WithBufferSize(size int) *Config
        + WithCallback(cb Callback) *Config
        + WithQueue(q Queue) *Config

    }
    interface Queue  {
        + Push(value <font color=blue>interface</font>{})
        + Pop() <font color=blue>interface</font>{}

    }
    class WriteAsyncer << (S,Aquamarine) >> {
        + Stop()
        + Write(p []byte) (int, error)

    }
    interface Writer  {
        + Write( []byte) (int, error)
        + Stop()

    }
    class emptyCallback << (S,Aquamarine) >> {
        + OnWriteFailed( []byte,  error)

    }
}

"law.Writer" <|-- "law.WriteAsyncer"
"law.Callback" <|-- "law.emptyCallback"

namespace lockfree {
    class LockFreeQueue << (S,Aquamarine) >> {
        + Push(value <font color=blue>interface</font>{})
        + Pop() <font color=blue>interface</font>{}
        + Length() int64
        + Reset()

    }
    class Node << (S,Aquamarine) >> {
        + Reset()

    }
    class NodePool << (S,Aquamarine) >> {
        + Get() *Node
        + Put(n *Node)

    }
}

"law.Queue" <|-- "lockfree.LockFreeQueue"

namespace utils {
    class BlackHoleWriter << (S,Aquamarine) >> {
        + Write(p []byte) (int, error)

    }
}


namespace writer {
    class BufferPool << (S,Aquamarine) >> {
        + Get() *bytes.Buffer
        + Put(e *bytes.Buffer)

    }
    class Status << (S,Aquamarine) >> {
        + IsRunning() bool
        + SetRunning(running bool)
        + GetExecuteAt() int64
        + SetExecuteAt(executeAt int64)

    }
}

left to right direction

writer-[hidden]right- utils

hide fields

@enduml