Java to Go converter - 2
678 views
Skip to first unread message
alex-coder
Mar 27, 2022, 12:11:48 PM3/27/22
to golang-nuts
After several months of switching from Java to Golang, it seemed to me that
it would be interesting to make the translation of Java code into Golang automatically.
The text below shows what has been done so far.
The work is not a prototype, but rather indicates the possibility of achieving a result.
Therefore, I deliberately simplify the development context of the Converter where it was
possible.
At first it seemed important to me that between Java and Go there is a difference
between the implementation of the Dynamic Dispatching, more precisely, there is no
Dynamic Dispatching in Go. The applied solution in the current implementation
looks not only ugly but even violates the several very important rules of the OO design,
I'm not kidding here. But this option looks like that it will be working.
Onward I will provide the 4 code samples in Java, followed by the automatically
generated Golang code and comments as needed.
1. Of course, I started with the most popular program: "Hello World".
package main;
public class HelloWorld {
public static void main( String[] args){
System.out.println("Hello World");
}
}
Converter gave out:
package main
import (
"fmt"
"os"
)
type HelloWorld struct{}
func main() {
var args []string = os.Args
var hw HelloWorld = HelloWorld{}
hw.HelloWorld_main(args)
}
/** generated method **/
func (helloWorld *HelloWorld) HelloWorld_main(args []string) {
fmt.Println("Hello World")
}
2. Next, it was interesting to deal with the problem of a simple inheritance.
package main;
public class TestInheritance {
public static void main( String[] args){
Inheritance inh=null;
inh=new Second();
inh.hello();
inh=new Third();
inh.hello();
}
}
public interface Inheritance {
public void hello();
}
class Second implements Inheritance {
public void hello(){
System.out.println("Second");
}
}
class Third implements Inheritance {
public void hello(){
System.out.println("Third");
}
}
Converter gave out:
package main
import (
"fmt"
"os"
)
type TestInheritance struct{}
func main() {
var args []string = os.Args
var ti TestInheritance = TestInheritance{}
ti.TestInheritance_main(args)
}
/** generated method **/
func (testInheritance *TestInheritance) TestInheritance_main(args []string) {
var inh Inheritance
inh = AddressSecond(Second{})
inh.hello()
inh = AddressThird(Third{})
inh.hello()
}
type Inheritance interface {
hello()
}
type Second struct{}
func (second *Second) hello() {
fmt.Println("Second")
}
type Third struct{}
func (third *Third) hello() {
fmt.Println("Third")
}
func AddressSecond(s Second) *Second { return &s }
func AddressThird(t Third) *Third { return &t }
3. In the following example, it is necessary to correctly define
a common interface for the inheritance tree.
package no.packeges;
public class TestExtension {
public static void main( String[] args){
TestExtension te=new TestExtension();
te.hello();
te=new Second();
te.hello();
te=new Third();
te.hello();
te=new Fourth();
te.hello();
}
public void hello(){
System.out.println("hello");
}
}
class Second extends TestExtension {
public void hello(){
System.out.println("Second");
}
}
class Third extends TestExtension {
public void hello(){
System.out.println("Third");
}
}
class Fourth extends Third {
public void hello(){
System.out.println("Fourth");
}
}
Converter gave out:
package main
import (
"fmt"
"os"
)
type TestExtension struct{}
func main() {
var args []string = os.Args
var te TestExtension = TestExtension{}
te.TestExtension_main(args)
}
func (testExtension *TestExtension) hello() {
fmt.Println("hello")
}
/** generated method **/
func (testExtension *TestExtension) TestExtension_main(args []string) {
var te ITestExtension = AddressTestExtension(TestExtension{})
te.hello()
te = AddressSecond(Second{})
te.hello()
te = AddressThird(Third{})
te.hello()
te = AddressFourth(Fourth{})
te.hello()
}
type Second struct {
TestExtension
}
func (second *Second) hello() {
fmt.Println("Second")
}
type Third struct {
TestExtension
}
func (third *Third) hello() {
fmt.Println("Third")
}
type Fourth struct {
Third
}
func (fourth *Fourth) hello() {
fmt.Println("Fourth")
}
type ITestExtension interface {
/** Generated Method */
hello()
}
func AddressSecond(s Second) *Second { return &s }
func AddressThird(t Third) *Third { return &t }
func AddressTestExtension(t TestExtension) *TestExtension { return &t }
func AddressFourth(f Fourth) *Fourth { return &f }
4. Now the Dynamic Dispatching absence. The problematic method in
the last sample is the amount() in class Repeater.
Without rewriting the code, I think it would be impossible to
invoke it correctly.
package main;
public class Speaker {
String message;
public static void main( String[] args){
Speaker sp = new Speaker("Say hello !");
System.out.println(sp.amount());
sp.speak();
Repeater rp = new Repeater("Say hello !",3);
System.out.println(rp.amount());
rp.speak();
}
public Speaker( String message){
this.message=message;
}
public void speak(){
for (int i=0; i < amount(); i++) {
System.out.println(this.message);
}
}
public int amount(){
return 1;
}
}
class Repeater extends Speaker {
int to_repeat=0;
public Repeater( String message, int amount){
super(message);
this.to_repeat=amount;
}
public int amount(){
return this.to_repeat;
}
}
Converter gave out:
package main
import (
"fmt"
"os"
)
type Speaker struct {
message string
}
func main() {
var args []string = os.Args
var s_dummy Speaker = NewSpeaker("")
s_dummy.Speaker_main(args)
}
func NewSpeaker(message string) Speaker {
var speaker Speaker = Speaker{message}
return speaker
}
func (speaker *Speaker) speak() {
for i := 0; i < speaker.amount(); i++ {
fmt.Println(speaker.message)
}
}
func (speaker *Speaker) amount() int {
return 1
}
/** generated method **/
func (speaker *Speaker) Speaker_main(args []string) {
var sp ISpeaker = AddressSpeaker(NewSpeaker("Say hello !"))
fmt.Println(sp.amount())
sp.speak()
var rp ISpeaker = AddressRepeater(NewRepeater("Say hello !", 3))
fmt.Println(rp.amount())
rp.speak()
}
type Repeater struct {
Speaker
to_repeat int
}
func NewRepeater(message string, amount int) Repeater {
var repeater Repeater = Repeater{NewSpeaker(message), amount}
return repeater
}
func (repeater *Repeater) amount() int {
return repeater.to_repeat
}
func (repeater *Repeater) speak() {
for i := 0; i < repeater.amount(); i++ {
fmt.Println(repeater.message)
}
}
type ISpeaker interface {
/** Generated Method */
amount() int
/** Generated Method */
speak()
}
func AddressRepeater(r Repeater) *Repeater { return &r }
func AddressSpeaker(s Speaker) *Speaker { return &s }
5. I will be thankful for any feedback.
Thanks to everyone.
it would be interesting to make the translation of Java code into Golang automatically.
The text below shows what has been done so far.
The work is not a prototype, but rather indicates the possibility of achieving a result.
Therefore, I deliberately simplify the development context of the Converter where it was
possible.
At first it seemed important to me that between Java and Go there is a difference
between the implementation of the Dynamic Dispatching, more precisely, there is no
Dynamic Dispatching in Go. The applied solution in the current implementation
looks not only ugly but even violates the several very important rules of the OO design,
I'm not kidding here. But this option looks like that it will be working.
Onward I will provide the 4 code samples in Java, followed by the automatically
generated Golang code and comments as needed.
1. Of course, I started with the most popular program: "Hello World".
package main;
public class HelloWorld {
public static void main( String[] args){
System.out.println("Hello World");
}
}
Converter gave out:
package main
import (
"fmt"
"os"
)
type HelloWorld struct{}
func main() {
var args []string = os.Args
var hw HelloWorld = HelloWorld{}
hw.HelloWorld_main(args)
}
/** generated method **/
func (helloWorld *HelloWorld) HelloWorld_main(args []string) {
fmt.Println("Hello World")
}
2. Next, it was interesting to deal with the problem of a simple inheritance.
package main;
public class TestInheritance {
public static void main( String[] args){
Inheritance inh=null;
inh=new Second();
inh.hello();
inh=new Third();
inh.hello();
}
}
public interface Inheritance {
public void hello();
}
class Second implements Inheritance {
public void hello(){
System.out.println("Second");
}
}
class Third implements Inheritance {
public void hello(){
System.out.println("Third");
}
}
Converter gave out:
package main
import (
"fmt"
"os"
)
type TestInheritance struct{}
func main() {
var args []string = os.Args
var ti TestInheritance = TestInheritance{}
ti.TestInheritance_main(args)
}
/** generated method **/
func (testInheritance *TestInheritance) TestInheritance_main(args []string) {
var inh Inheritance
inh = AddressSecond(Second{})
inh.hello()
inh = AddressThird(Third{})
inh.hello()
}
type Inheritance interface {
hello()
}
type Second struct{}
func (second *Second) hello() {
fmt.Println("Second")
}
type Third struct{}
func (third *Third) hello() {
fmt.Println("Third")
}
func AddressSecond(s Second) *Second { return &s }
func AddressThird(t Third) *Third { return &t }
3. In the following example, it is necessary to correctly define
a common interface for the inheritance tree.
package no.packeges;
public class TestExtension {
public static void main( String[] args){
TestExtension te=new TestExtension();
te.hello();
te=new Second();
te.hello();
te=new Third();
te.hello();
te=new Fourth();
te.hello();
}
public void hello(){
System.out.println("hello");
}
}
class Second extends TestExtension {
public void hello(){
System.out.println("Second");
}
}
class Third extends TestExtension {
public void hello(){
System.out.println("Third");
}
}
class Fourth extends Third {
public void hello(){
System.out.println("Fourth");
}
}
Converter gave out:
package main
import (
"fmt"
"os"
)
type TestExtension struct{}
func main() {
var args []string = os.Args
var te TestExtension = TestExtension{}
te.TestExtension_main(args)
}
func (testExtension *TestExtension) hello() {
fmt.Println("hello")
}
/** generated method **/
func (testExtension *TestExtension) TestExtension_main(args []string) {
var te ITestExtension = AddressTestExtension(TestExtension{})
te.hello()
te = AddressSecond(Second{})
te.hello()
te = AddressThird(Third{})
te.hello()
te = AddressFourth(Fourth{})
te.hello()
}
type Second struct {
TestExtension
}
func (second *Second) hello() {
fmt.Println("Second")
}
type Third struct {
TestExtension
}
func (third *Third) hello() {
fmt.Println("Third")
}
type Fourth struct {
Third
}
func (fourth *Fourth) hello() {
fmt.Println("Fourth")
}
type ITestExtension interface {
/** Generated Method */
hello()
}
func AddressSecond(s Second) *Second { return &s }
func AddressThird(t Third) *Third { return &t }
func AddressTestExtension(t TestExtension) *TestExtension { return &t }
func AddressFourth(f Fourth) *Fourth { return &f }
4. Now the Dynamic Dispatching absence. The problematic method in
the last sample is the amount() in class Repeater.
Without rewriting the code, I think it would be impossible to
invoke it correctly.
package main;
public class Speaker {
String message;
public static void main( String[] args){
Speaker sp = new Speaker("Say hello !");
System.out.println(sp.amount());
sp.speak();
Repeater rp = new Repeater("Say hello !",3);
System.out.println(rp.amount());
rp.speak();
}
public Speaker( String message){
this.message=message;
}
public void speak(){
for (int i=0; i < amount(); i++) {
System.out.println(this.message);
}
}
public int amount(){
return 1;
}
}
class Repeater extends Speaker {
int to_repeat=0;
public Repeater( String message, int amount){
super(message);
this.to_repeat=amount;
}
public int amount(){
return this.to_repeat;
}
}
Converter gave out:
package main
import (
"fmt"
"os"
)
type Speaker struct {
message string
}
func main() {
var args []string = os.Args
var s_dummy Speaker = NewSpeaker("")
s_dummy.Speaker_main(args)
}
func NewSpeaker(message string) Speaker {
var speaker Speaker = Speaker{message}
return speaker
}
func (speaker *Speaker) speak() {
for i := 0; i < speaker.amount(); i++ {
fmt.Println(speaker.message)
}
}
func (speaker *Speaker) amount() int {
return 1
}
/** generated method **/
func (speaker *Speaker) Speaker_main(args []string) {
var sp ISpeaker = AddressSpeaker(NewSpeaker("Say hello !"))
fmt.Println(sp.amount())
sp.speak()
var rp ISpeaker = AddressRepeater(NewRepeater("Say hello !", 3))
fmt.Println(rp.amount())
rp.speak()
}
type Repeater struct {
Speaker
to_repeat int
}
func NewRepeater(message string, amount int) Repeater {
var repeater Repeater = Repeater{NewSpeaker(message), amount}
return repeater
}
func (repeater *Repeater) amount() int {
return repeater.to_repeat
}
func (repeater *Repeater) speak() {
for i := 0; i < repeater.amount(); i++ {
fmt.Println(repeater.message)
}
}
type ISpeaker interface {
/** Generated Method */
amount() int
/** Generated Method */
speak()
}
func AddressRepeater(r Repeater) *Repeater { return &r }
func AddressSpeaker(s Speaker) *Speaker { return &s }
5. I will be thankful for any feedback.
Thanks to everyone.
alex-coder
Apr 4, 2022, 11:12:37 AM4/4/22
to golang-nuts
Another use case for automatically translating code
written in Java to Golang is Exception Handling.
The next example is likely to be about multithreading.
Example in Java:
package main
import (
"fmt"
"os"
)
func main() {
var args []string = os.Args
written in Java to Golang is Exception Handling.
The next example is likely to be about multithreading.
Example in Java:
package com.builder.start.here;
public class CatchException {
public static void main(String[] args) {
try {
new ThrowException().runme();
} catch (Exception e) {
System.out.println("yes, I caught it");
} finally {
System.out.println("finally processing");
}
}
}
class ThrowException{
public void runme() throws Exception{
throw new Exception();
}
}
public class CatchException {
public static void main(String[] args) {
try {
new ThrowException().runme();
} catch (Exception e) {
System.out.println("yes, I caught it");
} finally {
System.out.println("finally processing");
}
}
}
class ThrowException{
public void runme() throws Exception{
throw new Exception();
}
}
Converter gave out:
package main
import (
"fmt"
"os"
)
type CatchException struct{}
func main() {
var args []string = os.Args
var ce CatchException = CatchException{}
ce.CatchException_main(args)
}
/** generated method **/
func (catchException *CatchException) CatchException_main(args []string) {
defer func() {
if err := recover(); err != nil {
str := err.(string)
switch str {
case "Exception":
fmt.Println("yes, I caught it")
default:
fmt.Println("No, something is not right")
}
}
fmt.Println("finally processing")
}()
(&ThrowException{}).runme()
}
type ThrowException struct{}
func (throwException *ThrowException) runme() {
panic("Exception")
}
ce.CatchException_main(args)
}
/** generated method **/
func (catchException *CatchException) CatchException_main(args []string) {
defer func() {
if err := recover(); err != nil {
str := err.(string)
switch str {
case "Exception":
fmt.Println("yes, I caught it")
default:
fmt.Println("No, something is not right")
}
}
fmt.Println("finally processing")
}()
(&ThrowException{}).runme()
}
type ThrowException struct{}
func (throwException *ThrowException) runme() {
panic("Exception")
}
воскресенье, 27 марта 2022 г. в 15:11:48 UTC+3, alex-coder:
alex-coder
Apr 7, 2022, 3:52:25 PM4/7/22
to golang-nuts
Thanks for the comments about generating code to handle exceptions. . Here it is a new version.
case "Exception":
fmt.Println("yes, I caught it")
default:
fmt.Println("No, something is not right")
}
}
fmt.Println("finally processing")
}()
(&ThrowException{}).runme()
}
type ThrowException struct{}
func (throwException *ThrowException) runme() {
package main
import (
"fmt"
"os"
)
type CatchException struct{}
func main() {
var args []string = os.Args
var ce CatchException = CatchException{}
ce.CatchException_main(args)
}
/** generated method **/
func (catchException *CatchException) CatchException_main(args []string) {
defer func() {
if err := recover(); err != nil {
import (
"fmt"
"os"
)
type CatchException struct{}
func main() {
var args []string = os.Args
var ce CatchException = CatchException{}
ce.CatchException_main(args)
}
/** generated method **/
func (catchException *CatchException) CatchException_main(args []string) {
defer func() {
if err := recover(); err != nil {
exc := err.(Exception)
switch exc.msg {
switch exc.msg {
case "Exception":
fmt.Println("yes, I caught it")
default:
fmt.Println("No, something is not right")
}
}
fmt.Println("finally processing")
}()
(&ThrowException{}).runme()
}
type ThrowException struct{}
func (throwException *ThrowException) runme() {
panic(Exception{"Exception"})
}
type Exception struct {
msg string
}
}
type Exception struct {
msg string
}
понедельник, 4 апреля 2022 г. в 14:12:37 UTC+3, alex-coder:
alex-coder
Apr 28, 2022, 4:08:51 PM4/28/22
to golang-nuts
So, multithreading.
I found a simple example from Oracle with the wonderful name "Bad Threads" there:
https://docs.oracle.com/javase/tutorial/essential/concurrency/QandE/questions.html , simplified it even more, called the example a new simple name One and extend a Converter to translate the code to Golang.
There is no similar processing for InterruptedException in go, so the Converter does not translate the processing of this interrupt in any way. If anyone has a relatively small example in Java, please share it.
Java code:
package run.me;
public class One {
String msg;
public static void main( String[] args) throws InterruptedException {
One one=new One();
one.msg="Initial message";
System.out.println("main:before start:" + one.msg + " second part of");
new Second(one).start();
one.msg="after go start";
Thread.sleep(2000);
System.out.println("main:about to end:" + one.msg);
}
}
class Second extends Thread {
One one;
public Second( One one){
this.one=one;
}
public void run(){
try {
sleep(1000);
} catch ( InterruptedException e) {
}
System.out.println("run:after sleep:" + one.msg);
one.msg="try to change msg";
}
}
Converter выдал:
package main
import (
"fmt"
"os"
"time"
)
type One struct {
msg *string
}
func NewOne() *One {
var one One = One{}
return &one
}
func main() {
var args []string = os.Args
var o_dummy *One = NewOne()
o_dummy.One_main(&args)
}
/** generated method **/
func (one_one *One) One_main(args *[]string) {
var one *One = NewOne()
s := "Initial message"
one.msg = &s
fmt.Println("main:before start:" + *one.msg + " second part of")
go NewSecond(one).run()
s_s := "after go start"
one.msg = &s_s
time.Sleep(2000)
fmt.Println("main:about to end:" + *one.msg)
}
type Second struct {
one *One
}
func NewSecond(one *One) *Second {
var second Second = Second{one}
return &second
}
func (second *Second) run() {
time.Sleep(1000)
fmt.Println("run:after sleep:" + *second.one.msg)
s_s_s := "try to change msg"
second.one.msg = &s_s_s
}
The next example will probably be about channel's.
If anyone has an interesting example, write me, I'll think about how to solve it. I just can't promise that it will be quickly. :-)
Thank you to all !
I found a simple example from Oracle with the wonderful name "Bad Threads" there:
https://docs.oracle.com/javase/tutorial/essential/concurrency/QandE/questions.html , simplified it even more, called the example a new simple name One and extend a Converter to translate the code to Golang.
There is no similar processing for InterruptedException in go, so the Converter does not translate the processing of this interrupt in any way. If anyone has a relatively small example in Java, please share it.
Java code:
package run.me;
public class One {
String msg;
public static void main( String[] args) throws InterruptedException {
One one=new One();
one.msg="Initial message";
System.out.println("main:before start:" + one.msg + " second part of");
new Second(one).start();
one.msg="after go start";
Thread.sleep(2000);
System.out.println("main:about to end:" + one.msg);
}
}
class Second extends Thread {
One one;
public Second( One one){
this.one=one;
}
public void run(){
try {
sleep(1000);
} catch ( InterruptedException e) {
}
System.out.println("run:after sleep:" + one.msg);
one.msg="try to change msg";
}
}
Converter выдал:
package main
import (
"fmt"
"os"
)
type One struct {
msg *string
}
func NewOne() *One {
var one One = One{}
return &one
}
func main() {
var args []string = os.Args
o_dummy.One_main(&args)
}
/** generated method **/
func (one_one *One) One_main(args *[]string) {
var one *One = NewOne()
s := "Initial message"
one.msg = &s
fmt.Println("main:before start:" + *one.msg + " second part of")
go NewSecond(one).run()
s_s := "after go start"
one.msg = &s_s
time.Sleep(2000)
fmt.Println("main:about to end:" + *one.msg)
}
type Second struct {
one *One
}
func NewSecond(one *One) *Second {
var second Second = Second{one}
return &second
}
func (second *Second) run() {
time.Sleep(1000)
fmt.Println("run:after sleep:" + *second.one.msg)
s_s_s := "try to change msg"
second.one.msg = &s_s_s
}
The next example will probably be about channel's.
If anyone has an interesting example, write me, I'll think about how to solve it. I just can't promise that it will be quickly. :-)
Thank you to all !
четверг, 7 апреля 2022 г. в 18:52:25 UTC+3, alex-coder:
alex-coder
May 17, 2022, 2:49:09 PM5/17/22
to golang-nuts
In Go, multithreading is one of the main features, respectively, the ability to convert Java code using multithreading into Go code automatically, which uses channels, is very important.
I found a suitable example of ProducerConsumerExample from Oracle there:Oracle sample, where the Drop class is a candidate for conversion to Go using channels.
But, now I give an intermediate result without channels.
Also, I read the opinion that the conversion of Java code where annotations are used in runtime is impossible. It is necessary to investigate the problem and try to understand if it is possible to solve it somehow. Before transferring a project from the status of "possibility of achievement" to the status of "prototype", it is necessary to see what can be done with these problems in relation to annotations.
public static void main(String[] args) {
}
}
Converter gave out:
package main
import (
"fmt"
}
func main() {
var args []string = os.Args
Thank you to all very much.
I found a suitable example of ProducerConsumerExample from Oracle there:Oracle sample, where the Drop class is a candidate for conversion to Go using channels.
But, now I give an intermediate result without channels.
Also, I read the opinion that the conversion of Java code where annotations are used in runtime is impossible. It is necessary to investigate the problem and try to understand if it is possible to solve it somehow. Before transferring a project from the status of "possibility of achievement" to the status of "prototype", it is necessary to see what can be done with these problems in relation to annotations.
Java code:
package com.builder.start.here;
import java.util.Random;
public class RunMeDrop {
package com.builder.start.here;
import java.util.Random;
public class RunMeDrop {
public static void main(String[] args) {
Drop drop = new Drop();
(new Thread(new Producer(drop))).start();
(new Thread(new Consumer(drop))).start();
}
}
class Drop {
// Message sent from producer
// to consumer.
private String message;
// True if consumer should wait
// for producer to send message,
// false if producer should wait for
// consumer to retrieve message.
private boolean empty = true;
public synchronized String take() {
// Wait until message is
// available.
while (empty) {
try {
wait();
} catch (InterruptedException e) {}
}
// Toggle status.
empty = true;
// Notify producer that
// status has changed.
notifyAll();
return message;
}
public synchronized void put(String message) {
// Wait until message has
// been retrieved.
while (!empty) {
try {
wait();
} catch (InterruptedException e) {}
}
// Toggle status.
empty = false;
// Store message.
this.message = message;
// Notify consumer that status
// has changed.
notifyAll();
}
}
class Consumer implements Runnable {
private Drop drop;
public Consumer(Drop drop) {
this.drop = drop;
}
public void run() {
Random random = new Random();
for (
String message = drop.take();
! message.equals("DONE");
message = drop.take()) {
System.out.format(
"MESSAGE RECEIVED: %s%n", message);
try {
Thread.sleep(random.nextInt(5000));
} catch (InterruptedException e) {}
}
}
}
class Producer implements Runnable {
private Drop drop;
public Producer(Drop drop) {
this.drop = drop;
}
public void run() {
String importantInfo[] = {
"Mares eat oats",
"Does eat oats",
"Little lambs eat ivy",
"A kid will eat ivy too"
};
Random random = new Random();
for (int i = 0; i < importantInfo.length; i++) {
drop.put(importantInfo[i]);
try {
Thread.sleep(random.nextInt(5000));
} catch (InterruptedException e) {}
}
drop.put("DONE");
(new Thread(new Producer(drop))).start();
(new Thread(new Consumer(drop))).start();
}
}
class Drop {
// Message sent from producer
// to consumer.
private String message;
// True if consumer should wait
// for producer to send message,
// false if producer should wait for
// consumer to retrieve message.
private boolean empty = true;
public synchronized String take() {
// Wait until message is
// available.
while (empty) {
try {
wait();
} catch (InterruptedException e) {}
}
// Toggle status.
empty = true;
// Notify producer that
// status has changed.
notifyAll();
return message;
}
public synchronized void put(String message) {
// Wait until message has
// been retrieved.
while (!empty) {
try {
wait();
} catch (InterruptedException e) {}
}
// Toggle status.
empty = false;
// Store message.
this.message = message;
// Notify consumer that status
// has changed.
notifyAll();
}
}
class Consumer implements Runnable {
private Drop drop;
public Consumer(Drop drop) {
this.drop = drop;
}
public void run() {
Random random = new Random();
for (
String message = drop.take();
! message.equals("DONE");
message = drop.take()) {
System.out.format(
"MESSAGE RECEIVED: %s%n", message);
try {
Thread.sleep(random.nextInt(5000));
} catch (InterruptedException e) {}
}
}
}
class Producer implements Runnable {
private Drop drop;
public Producer(Drop drop) {
this.drop = drop;
}
public void run() {
String importantInfo[] = {
"Mares eat oats",
"Does eat oats",
"Little lambs eat ivy",
"A kid will eat ivy too"
};
Random random = new Random();
for (int i = 0; i < importantInfo.length; i++) {
drop.put(importantInfo[i]);
try {
Thread.sleep(random.nextInt(5000));
} catch (InterruptedException e) {}
}
drop.put("DONE");
}
}
Converter gave out:
package main
import (
"fmt"
"math/rand"
"os"
"sync"
"time"
)
type RunMe struct{}
func NewRunMe() *RunMe {
var runMe RunMe = RunMe{}
return &runMe
"os"
"sync"
"time"
)
type RunMe struct{}
func NewRunMe() *RunMe {
var runMe RunMe = RunMe{}
return &runMe
}
func main() {
var args []string = os.Args
var rm *RunMe = NewRunMe()
rm.RunMe_main(&args)
}
/** generated method **/
func (runMe *RunMe) RunMe_main(args *[]string) {
wg := &sync.WaitGroup{}
var drop *Drop = NewDrop()
wg.Add(1)
go (&Thread{NewProducer(drop)}).run(wg)
wg.Add(1)
go (&Thread{NewConsumer(drop)}).run(wg)
wg.Wait()
}
type Drop struct {
/** generated field */
cond *sync.Cond
message *string
empty *bool
}
func NewDrop() *Drop {
var drop Drop = Drop{}
drop.cond = sync.NewCond(&sync.Mutex{})
empty := true
drop.empty = &empty
return &drop
}
func (drop *Drop) take() string {
drop.cond.L.Lock()
for *drop.empty {
drop.cond.Wait()
}
*drop.empty = true
drop.cond.L.Unlock()
drop.cond.Broadcast()
return *drop.message
}
func (drop *Drop) put(message *string) {
drop.cond.L.Lock()
for !*drop.empty {
drop.cond.Wait()
}
*drop.empty = false
drop.message = message
drop.cond.L.Unlock()
drop.cond.Broadcast()
}
type Consumer struct {
drop *Drop
}
func NewConsumer(drop *Drop) *Consumer {
var consumer Consumer = Consumer{drop}
return &consumer
}
func (consumer *Consumer) run(wg *sync.WaitGroup) {
defer wg.Done()
var random *Random = NewRandom()
for message := consumer.drop.take();
message != "DONE";
message = consumer.drop.take() {
fmt.Printf("MESSAGE RECEIVED: %s\n", message)
time.Sleep(random.nextInt(5000))
}
}
type Producer struct {
drop *Drop
}
func NewProducer(drop *Drop) *Producer {
var producer Producer = Producer{drop}
return &producer
}
func (producer *Producer) run(wg *sync.WaitGroup) {
defer wg.Done()
var importantInfo [4]string = [4]string{
"Mares eat oats",
"Does eat oats",
"Little lambs eat ivy",
"A kid will eat ivy too",
}
var random *Random = NewRandom()
for i := 0; i < len(importantInfo); i++ {
producer.drop.put(&importantInfo[i])
time.Sleep(random.nextInt(5000))
}
s := "DONE"
producer.drop.put(&s)
}
type Random struct{}
func NewRandom() *Random {
var random Random = Random{}
return &random
}
func (r *Random) nextInt(n int) time.Duration {
return time.Duration(rand.Intn(n))
}
type Thread struct {
Runnable
}
func (t *Thread) run(wg *sync.WaitGroup) {
t.Runnable.run(wg)
}
type Runnable interface {
run(wg *sync.WaitGroup)
}
The Go Playground, you can run code there:
Go Playground.
rm.RunMe_main(&args)
}
/** generated method **/
func (runMe *RunMe) RunMe_main(args *[]string) {
wg := &sync.WaitGroup{}
var drop *Drop = NewDrop()
wg.Add(1)
go (&Thread{NewProducer(drop)}).run(wg)
wg.Add(1)
go (&Thread{NewConsumer(drop)}).run(wg)
wg.Wait()
}
type Drop struct {
/** generated field */
cond *sync.Cond
message *string
empty *bool
}
func NewDrop() *Drop {
var drop Drop = Drop{}
drop.cond = sync.NewCond(&sync.Mutex{})
empty := true
drop.empty = &empty
return &drop
}
func (drop *Drop) take() string {
drop.cond.L.Lock()
for *drop.empty {
drop.cond.Wait()
}
*drop.empty = true
drop.cond.L.Unlock()
drop.cond.Broadcast()
return *drop.message
}
func (drop *Drop) put(message *string) {
drop.cond.L.Lock()
for !*drop.empty {
drop.cond.Wait()
}
*drop.empty = false
drop.message = message
drop.cond.L.Unlock()
drop.cond.Broadcast()
}
type Consumer struct {
drop *Drop
}
func NewConsumer(drop *Drop) *Consumer {
var consumer Consumer = Consumer{drop}
return &consumer
}
func (consumer *Consumer) run(wg *sync.WaitGroup) {
defer wg.Done()
var random *Random = NewRandom()
for message := consumer.drop.take();
message != "DONE";
message = consumer.drop.take() {
fmt.Printf("MESSAGE RECEIVED: %s\n", message)
time.Sleep(random.nextInt(5000))
}
}
type Producer struct {
drop *Drop
}
func NewProducer(drop *Drop) *Producer {
var producer Producer = Producer{drop}
return &producer
}
func (producer *Producer) run(wg *sync.WaitGroup) {
defer wg.Done()
var importantInfo [4]string = [4]string{
"Mares eat oats",
"Does eat oats",
"Little lambs eat ivy",
"A kid will eat ivy too",
}
var random *Random = NewRandom()
for i := 0; i < len(importantInfo); i++ {
producer.drop.put(&importantInfo[i])
time.Sleep(random.nextInt(5000))
}
s := "DONE"
producer.drop.put(&s)
}
type Random struct{}
func NewRandom() *Random {
var random Random = Random{}
return &random
}
func (r *Random) nextInt(n int) time.Duration {
return time.Duration(rand.Intn(n))
}
type Thread struct {
Runnable
}
func (t *Thread) run(wg *sync.WaitGroup) {
t.Runnable.run(wg)
}
type Runnable interface {
run(wg *sync.WaitGroup)
}
The Go Playground, you can run code there:
Go Playground.
Thank you to all very much.
четверг, 28 апреля 2022 г. в 19:08:51 UTC+3, alex-coder:
Henry
May 18, 2022, 4:39:49 AM5/18/22
to golang-nuts
Kudos to you. Java to Go is a lot of work. Java is a more complex language. It has more features and more possibilities for expressing the same model/algorithm. You need to identify all these possibilities, parse, and convert them to Go. I could be wrong about this, but it may be easier to convert Java bytecode to Go.
alex-coder
May 18, 2022, 10:43:07 AM5/18/22
to golang-nuts
Henry,
thank you, it is quite possible that you are right, at least I should check it out.
Thank you again.
среда, 18 мая 2022 г. в 07:39:49 UTC+3, Henry:
alex-coder
May 22, 2022, 6:49:42 AM5/22/22
to golang-nuts
So, channels.
Converter can now convert Java classes to Go channels where possible. The previous example contains a Drop class that matches the conversion criteria, as shown in the Go example code below. Accordingly, if the converter "does not find" a class suitable for conversion, Java multithreading will be converted to Go code without using the translation into channels.
Java code:
package com.builder.start.here;
import java.util.Random;
public class RunMe {
wg.Add(1)
go (&Thread{NewProducer(drop)}).run(wg)
wg.Add(1)
go (&Thread{NewConsumer(drop)}).run(wg)
wg.Wait()
}
var consumer Consumer = Consumer{drop}
return &consumer
}
func (consumer *Consumer) run(wg *sync.WaitGroup) {
defer wg.Done()
var random *Random = NewRandom()
fmt.Printf("MESSAGE RECEIVED: %s\n", message)
time.Sleep(random.nextInt(5000))
}
}
type Producer struct {
var producer Producer = Producer{drop}
return &producer
}
func (producer *Producer) run(wg *sync.WaitGroup) {
defer wg.Done()
var importantInfo [4]string = [4]string{
"Mares eat oats",
"Does eat oats",
"Little lambs eat ivy",
"A kid will eat ivy too"}
}
type Random struct{}
func NewRandom() *Random {
var random Random = Random{}
return &random
}
func (r *Random) nextInt(n int) time.Duration { return time.Duration(rand.Intn(n)) }
type Thread struct {
Runnable
}
func (t *Thread) run(wg *sync.WaitGroup) {
t.Runnable.run(wg)
}
type Runnable interface {
run(wg *sync.WaitGroup)
}
Thank you to all very much.
Converter can now convert Java classes to Go channels where possible. The previous example contains a Drop class that matches the conversion criteria, as shown in the Go example code below. Accordingly, if the converter "does not find" a class suitable for conversion, Java multithreading will be converted to Go code without using the translation into channels.
Java code:
package com.builder.start.here;
import java.util.Random;
Converter gave out:
var drop chan string = make(chan string)
wg.Add(1)
go (&Thread{NewProducer(drop)}).run(wg)
wg.Add(1)
go (&Thread{NewConsumer(drop)}).run(wg)
wg.Wait()
}
type Consumer struct {
drop chan string
}
func NewConsumer(drop chan string) *Consumer {
drop chan string
}
func NewConsumer(drop chan string) *Consumer {
var consumer Consumer = Consumer{drop}
return &consumer
}
func (consumer *Consumer) run(wg *sync.WaitGroup) {
defer wg.Done()
var random *Random = NewRandom()
for message := <-consumer.drop;
message != "DONE";
message = <-consumer.drop {
message != "DONE";
message = <-consumer.drop {
fmt.Printf("MESSAGE RECEIVED: %s\n", message)
time.Sleep(random.nextInt(5000))
}
}
type Producer struct {
drop chan string
}
func NewProducer(drop chan string) *Producer {
}
func NewProducer(drop chan string) *Producer {
var producer Producer = Producer{drop}
return &producer
}
func (producer *Producer) run(wg *sync.WaitGroup) {
defer wg.Done()
var importantInfo [4]string = [4]string{
"Mares eat oats",
"Does eat oats",
"Little lambs eat ivy",
"A kid will eat ivy too"}
var random *Random = NewRandom()
for i := 0; i < len(importantInfo); i++ {
for i := 0; i < len(importantInfo); i++ {
producer.drop <- (importantInfo[i])
time.Sleep(random.nextInt(5000))
}
producer.drop <- ("DONE")
time.Sleep(random.nextInt(5000))
}
producer.drop <- ("DONE")
}
type Random struct{}
func NewRandom() *Random {
var random Random = Random{}
return &random
}
func (r *Random) nextInt(n int) time.Duration { return time.Duration(rand.Intn(n)) }
type Thread struct {
Runnable
}
func (t *Thread) run(wg *sync.WaitGroup) {
t.Runnable.run(wg)
}
type Runnable interface {
run(wg *sync.WaitGroup)
}
You can run code there:
Now I'll take a break, I need to deal with the advices that I received.
Thank you to all very much.
среда, 18 мая 2022 г. в 13:43:07 UTC+3, alex-coder:
Oliveira Jose Carlos de - ICTS BSA
Aug 18, 2022, 6:58:03 PM8/18/22
to golang-nuts
Hi, I´m looking foward to find a Tool able to convert any Java Source code Project to a GoLang Project. I know that are Programming languages created for different propposal. Java is OOL and goLang is different. So convertion is possible, but I think is very complex. For me is much more easy look on Java Source code logic and write your own code in GoLang. I think....
I did it in the past, and writting code in a new language make de new code more maintenable.
alex-coder
Aug 22, 2022, 2:12:18 PM8/22/22
to golang-nuts
Hi, sorry for delay.
Despite my great interest in this task, I can not spend a lot of time on the project. But you're right, everything I've posted on go-nuts shows that conversion is very possible and in the same context that you're considering, if I understand you correctly of course . So far it looks like this:
syntactic analysis,
semantic analysis,
then there is code generation on Go from AST.
syntactic analysis,
semantic analysis,
then there is code generation on Go from AST.
Regards,
четверг, 18 августа 2022 г. в 21:58:03 UTC+3, Oliveira Jose Carlos de - ICTS BSA:
Reply all
Reply to author
Forward
0 new messages