Future and Promice

var request = EventRequest(ticketNr)    //요청을만든다
var response = EventResponse = callEventService(request)   //응답이 완료될때까지 기다린다
var event:Event = reponse.event  //최종 이벤트값을 읽는다.
val trafficRequest = TrafficRequest{
  destination = event.location,
  arrivalTime = event.time
)
var trafficResponse = callTrafficService(trafficRequest )  //이벤트값을 가지고 다시 트래픽정보를 요청한다. 

var request = EventRequest(ticketNr)    //요청을만든다
val futureRoute : Future[Route] = Future{
  callEventService(request).event
}.map{ event =>
  val trafficRequest = TrafficRequest{
    destination = event.location,
    arrivalTime = event.time
  )
  callTrafficeService(trafficRequest).route  //교통 루트를 반환한다.
}

@FunctionalInterface
interface FuncB {
	public int calc(int a, int b);
}

@FunctionalInterface
interface FuncA {
	public int calc(int a);
}

FuncA F1 = (int a) -> a+1;
FuncA F2 = (int a) -> a+1;
FuncA F3 = (int a) -> a+1;
FuncB F4 = (int a,int b) -> a+b;
			
Integer input=1;
CompletableFuture<Integer> futureB  
  = CompletableFuture.supplyAsync(() -> F1.calc(1) );			  	

CompletableFuture<Integer> futureD
	= CompletableFuture.supplyAsync(() -> F3.calc(F2.calc(1))  );			

CompletableFuture<Void> combinedFuture 
  = CompletableFuture.allOf(futureB, futureD);

combinedFuture.get();						
Integer result = futureB.get() + futureD.get();			
System.out.println(result);

//Labda
Func<int, int> F1 = x => x + 1;
Func<int, int> F2 = x => x + 1;
Func<int, int> F3 = x => x + 1;
Func<int, int, int> F4 = delegate ( int x, int y ){
     return x + y;
};            

//Block with task
Task<int> futureA = Task.Factory.StartNew<int>(() => F1(1));
int c = F2(1);
int d = F3(c);
int f = F4(futureA.Result, d);
Console.WriteLine("ResultA:" + f);

//Continuation Tasks
var futureB = Task.Factory.StartNew<int>(() => F1(1));
var futureD = Task.Factory.StartNew<int>(() => F3(F2(1)));
var futureF = Task.Factory.ContinueWhenAll<int, int>(
                 new[] { futureB, futureD },
                 ( tasks ) => F4(futureB.Result, futureD.Result));

futureF.ContinueWith(( t ) =>
    Console.WriteLine("ResultF:" + t.Result)
);

Console.WriteLine("Code...End");

def sendTokafka(recode: ProducerRecod): Futrure[RecordMetadata] = {
  val promise : Promise[[RecordMetadata]] = Promise[RocordMetadata]() //RecordMetadata 타잎의 값을 돌려주는 약속을 만든다.
  val future:Future[RecordMetadata] = promise.future  //future에 대한 참조를 가져온다
  
  val callback = new CallBack(){  //송신성공시 카프카 콜백
    def onCompletition(metadata: RecordMetadata, e:Exception): Unit={
      if(e != null ) promise.failure(e)  //오류기록
      else promise.success(metadata)     //성공기록
    }
  }
  producer.send(record,callback)
  future
}

public class ReActor : ReceiveActor
{
  private ILoggingAdapter log = Context.GetLogger();

  public ReActor()
  {
      string myPath = Self.Path.ToString();

      Receive<string>(message => {
          Handle(message);                
      });

      Receive<DelayReply>(message => {
          Handle(message);
      });
  }

  public void Handle(string str)      //InMessage
  {
      Task.Run(async () =>
      {
          await Task.Delay(1000); //어떠한 값을 기다림
          DelayReply reply = new DelayReply();
          reply.message = str;
          return reply;
      }).PipeTo(Self);
  }

  public void Handle(DelayReply data) //Out
  {
      string logtrace = string.Format("I'am {0} RE:{1}", Self.Path, data.message);
      log.Info(data.message);
      Sender.Tell(data);
  }
          
}