Fedora Linux: Java

Showing posts with label Java. Show all posts

Protobuf Examples C++ and Java (2)

This sample .proto is taken from http://www.indelible.org/ink/protobuf-polymorphism/. Also see example 1

animal.proto

 package animal;

option java_outer_classname = "Animals";

message Cat
{
    optional bool declawed = 1;
}

message Dog
{
    optional uint32 bones_buried = 1;
}

message Animal
{
    required float weight = 1;
    optional Dog dog = 2;
    optional Cat cat = 3;
}

animal.cpp

#include 
#include "animal.pb.h"
using namespace std;
using namespace animal;

int main()
{
  Cat cat1;
  cat1.set_declawed(true);

  Animal animal;
  animal.set_weight(10.4);
  Cat* cat = animal.mutable_cat();

  cat->set_declawed(true);


  Dog *dog = animal.mutable_dog();
  dog->set_bones_buried (32);

  string s;
  animal.SerializeToString(&s);

  Animal animal2;

  animal2.ParseFromString(s);

  printf("weight %f\n", animal2.weight());

  if (animal.has_cat())
  {
    printf("cat %d\n", animal.cat().declawed());
  }

  if (animal.has_dog())
  {
    printf("dog %d\n", animal.dog().bones_buried());
  }

  return 0;
}

animal.java

import animal.Animals;
import com.google.protobuf.GeneratedMessage;
import com.google.protobuf.ExtensionRegistry;
import com.google.protobuf.*;
import java.io.IOException;

 
class AnimalExample {

 
    public static void main(String[] args) throws Exception {

        Animals.Animal animal =  Animals.Animal.newBuilder().
            setWeight(10.4F)
            .setDog(Animals.Dog.newBuilder().setBonesBuried(32).build())
            .setCat(Animals.Cat.newBuilder().setDeclawed(true).build())
            .build();
        
        

        byte[] data = animal.toByteArray();

        Animals.Animal animal2 = Animals.Animal.newBuilder().mergeFrom(data).build();
        
        System.out.println("Animal weight " + animal2.getWeight());

        if (animal2.hasCat()) {

            System.out.println("Cat " + animal2.getCat().getDeclawed());
        }

        if (animal2.hasDog()){
            System.out.println("Dog " + animal2.getDog().getBonesBuried());
        }
    }
    
}

Protobuf Examples for C++ and Java (1)

This sample .proto is taken from http://blog.wolfman.com/articles/2011/11/23/how-to-implement-polymorphic-protocol-buffers-in-java. The groovy is rewritten in Java and C++. Also see example 2

example.proto

package example;

option java_outer_classname = "Commands";

message BaseCommand {
        extensions 100 to max;

        enum CommandType {
                VERSION = 1;
                LOGIN   = 2;
        }
        required CommandType type = 1;
}


message Version {
        extend BaseCommand {
                required Version cmd = 100;
        }

        required fixed32 protocol = 1;
        required fixed32 versions = 2;
}

message Login {
        extend BaseCommand {
                required Login cmd = 101;
        }
        required string username = 1;
        required string password = 2;
}

example.cpp

#include 
#include "example.pb.h"
using namespace std;
using namespace example;

int main()
{
  string sl;


  BaseCommand b;


#if 0
  Version ver;
  ver.set_versions(10);
  ver.set_protocol(15);

  
  b.MutableExtension(Version::cmd)->set_versions(10);
  b.MutableExtension(Version::cmd)->set_protocol(15);

  b.set_type( BaseCommand::VERSION);
#else
  b.set_type( BaseCommand::LOGIN);

  b.MutableExtension(Login::cmd)->set_username("rain");
  b.MutableExtension(Login::cmd)->set_password("heavy");
  

#endif
  b.SerializeToString(&sl);


  printf("%d\n", sl.length());

  BaseCommand* bcmd = new BaseCommand();
  if (bcmd->ParseFromString(sl))
  {
    printf("ParsePartialFromString ok\n");
  }
  

  printf("%d\n", bcmd->type());
  switch(bcmd->type())
  {
    case BaseCommand::LOGIN:
    {
      printf("login\n");
      printf("%s %s\n", b.MutableExtension(Login::cmd)->username().c_str(), b.MutableExtension(Login::cmd)->password().c_str());

      break;
    }
    case BaseCommand::VERSION:
    {
      printf("version\n");


      printf("%d %d\n", b.MutableExtension(Version::cmd)->versions(), b.MutableExtension(Version::cmd)->protocol());
      break;
    }
    default:
      break;
  }

  return 1;
}

example.java

import example.Commands;
import example.Commands.BaseCommand;
import com.google.protobuf.GeneratedMessage;
import com.google.protobuf.ExtensionRegistry;
import java.io.IOException;

 
class ProtoBufExample {
        // Helper which wraps the BaseCommand around the extension command
        static  BaseCommand wrap(BaseCommand.CommandType type, GeneratedMessage.GeneratedExtension extension, Type cmd) {
                return BaseCommand.newBuilder().setType(type).setExtension(extension, cmd).build();
        }
 
        ExtensionRegistry registry;
 
        ProtoBufExample() {
                // we need to register all the extensions and tell the decoder about them
                // otherwise the extension will be ignored
                registry= ExtensionRegistry.newInstance();
                Commands.registerAllExtensions(registry);
        }
 
        BaseCommand buildVersion(int v1, int v2) {
                Commands.Version vers= Commands.Version.newBuilder().setProtocol(v1).setVersions(v2).build();
                // BaseCommand bcmd= BaseCommand.newBuilder().setType(BaseCommand.CommandType.VERSION).setExtension(Commands.Version.cmd, vers).build();
                return wrap(BaseCommand.CommandType.VERSION, Commands.Version.cmd, vers);
        }
 
        BaseCommand buildLogin(String username, String password) {
                Commands.Login l= Commands.Login.newBuilder().setUsername(username).setPassword(password).build();
                return wrap(BaseCommand.CommandType.LOGIN, Commands.Login.cmd, l);
        }
 
        BaseCommand decodeIt(byte [] ba) {
                // use the registry so extensions will be decoded
            try{
                BaseCommand b=BaseCommand.newBuilder().mergeFrom(ba, registry).build();
                return b;
            }
            catch (IOException e) {
                System.out.println("Unable to create  " +e.getMessage());
                return buildVersion(0,1);
            }

        }

 
    public static void main(String[] args) throws Exception {
        ProtoBufExample pb= new ProtoBufExample();
        BaseCommand b= pb.buildVersion(1234, 5678);
        //BaseCommand b= pb.buildLogin("user1", "test");
 
        System.out.println(b);
        System.out.println ("size: " + b.toByteArray().length);
 
        BaseCommand decoded= pb.decodeIt(b.toByteArray());
 
        System.out.println ("We got a "+ decoded.getType() +" message");
 
        // We can switch on the CommandType enum and extract the specific command type (extension) we got
        switch(decoded.getType()) {
        case VERSION:
            System.out.println (decoded.getExtension(Commands.Version.cmd));
            break;
                
        case LOGIN:
            System.out.println (decoded.getExtension(Commands.Login.cmd));
            break;
 
        default:
            System.out.println ("Don't know this type");
        }
    }
    
}

Java Basics

Primitive Types

byte
char - 16 bit
short
int
long - 64 bit
boolean
float
double

Variables

variable of primitive types holds value.
variable of non-primitive types holds reference.

Variable Storage

Static - static class variables
Local - primitives
Dynamic - non-primitives

Parameters

All the parameters are pass-by-value (since the variables can only be value or reference; for reference it is a copy of the reference).
There is no direct way change content of a primitive type with parameter (can wrap with array or object).

Class

Accessibility

public
private
protected - subclass and class from the same package.
package - member without any leading keyword get default package access.

no C++ const method

no ";" after class {}

Inheritance

no C++ multiple inheritance

Object is default base class if no base class is specified. Which is the root base class for all classes.
super is used to initialize superclass.

import Person;
public class Student extends Person
{
   private String major;
   public Student(String name, String major)
   {
      super(name);
      this.major=major;
   }
}

Static and Dynamic Binding

virtual by default

 void a();  //C++==>  virtual void a();

Abstract Methods

abstract a();  //C++==> virtual void a()=0;

Call Superclass Version

super.a();     //C++==> baseName::a();

Final Methods

Cannot be overriden in a subclass

final void a();

Exceptions

Java exception class must be a subclass of the java.lang.Exception class (which is a subclass of java.lang.Throwable).
C++ exception can be of any class.

Features of C++ does not exist in Java

Preprocessor
Enumeration Types
Templates
Operator Overloading
Named types (typedef)
Structs and unions
const class function member.

Java

http://triton.towson.edu/~mzimand/os/Lect2-java-tutorial.html
http://en.wikipedia.org/wiki/Comparison_of_Java_and_C%2B%2B
http://triton.towson.edu/~mzimand/os/Lect2-java-tutorial.html

Fedora Linux