HAMA 블로그

...작성중..

hadoop-2.2.0 경우는 이클립스에서  maven  으로 import 하면 됩니다만

string guy = null;

for(  Groups::iterator i = Groups.iterator();  i != Groups.end() ; ++i){
	
	player p = *i;
	
	if(p.id == 1){
		guy =  p.name;
	}
}

return guy;

player = Groups.findbyId(1);
if( player ){
	return player.name;
}
elsle{
	return null;
}

fmap (getName)  (findId 1) 

bool is_cool (const Thing& x) { ... }
find_if(begin, end, not1(ptr_fun(is_cool)));

select * from player  where id = 1  

public Table select (Selector where){

	Table resultTable = new ConcreteTable(null, columnNames.clone()};
	Results currentRow = (Results) rows();
	Cursor[] envelop = new Cursor[] { currentRow };

	while(currentRow.advance(){
		if(where.approve(envelope))
			resultTable.insert( currentRow.cloneRow());
	}
	
	return new UnmodifiableTable(resultTable);
}

struct table {
	....
}

table t [][];
              ....


for(int i = 0 ; i <  rows ; i++){
	for( int j = 0 ; j < cols; j++){
		...
	}
}

#include <stdio.h>

void apple(void)
{
  printf("apple");
};


int main()
{
  void (*fptr)(void);          // 선언
  fptr = apple;                // 대입
  fptr();                      // 호출
  someFunction(fptr);          // 매개변수로 넘김.
}

#include <iostream>
using namespace std;
class fruit
{
	public:
		void apple()
		{
			cout << "apple" << endl;
		}
		void berry()
		{
			cout << "berry" << endl;
		}
};

int main()
{
	fruit x, *y;
	void (fruit::*f)(void);    //  선언 
	
	f = &fruit::apple;         //  대입
	(x.*f)();                  //  호출

	f = &fruit::berry;
        y = new fruit;
	(y->*f)();

	delete y;
} 

class CHello
{
	void Say()
	{ 
		print(“hello”); 
        }
};

Void func1()
{
	CHello hello;                                             // CHello 의 객체 선언 
	boost::function< void ( void ) > memfunc;                 // boost::function 객체 선언
	memfunc = boost::bind( &CHello::DebugOut, hello, _1 );    // DebugOut 함수를 func 에 바인딩

        func2(memfunc);     
}     
                                                                      
Void func2(boost::function< void ( void ) >   _func)
{

    _func( 5 );     // CHello::Say() 가 호출!!!  	1.  행위를 하게함. ( observer 패턴)  
                    //                          2.  호출위치를 조절할수도 있고 
                    //                          3.  다른모듈에서 CHello를 호출.(디펜던시문제)

} 

#include <iostream>
#include <functional>

using namespace std;

int add(int a, int b) {
    return a + b;
}

int main() {
    auto f = bind(add, 1, 2);
    cout << f() << "\n";
}

///////////////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <functional>

using namespace std;
using namespace std:placeholders;

int add(int a, int b) {
    return a + b;
}

int main() {
    auto add1 = bind(add, 1, _1);
    cout << add1(100) << "\n";
}

boost::asio::ip::tcp::acceptor m_acceptor;
 
void handle_accept(Session* pSession, const boost::system::error_code& error)
{
  if (!error)
  {     
       std::cout << "클라이언트 접속 성공" << std::endl;
                   
       pSession->PostReceive();
  }
}
 
m_acceptor.async_accept( m_pSession->Socket(),
                         boost::bind(&TCP_Server::handle_accept,  // 함수 객체를 넘긴다. (함수포인터넘겨도됨)
                         this,
                         m_pSession,
                         boost::asio::placeholders::error)
                    );

boost::asio::ip::tcp::acceptor m_acceptor;
 
 
m_acceptor.async_accept( m_pSession->Socket(),
                     [this](boost::system::error_code error)   // 람다식을 넘김!!
                    {
                       if (!error)
                       {  
                          std::cout << "클라이언트 접속 성공" << std::endl;
                          m_pSession->PostReceive();
                       }
                      
                       StartAccept();
                    }
                    );

Public void foo()
{
        final int n = 1;
	Class  ActionListener() 
	{
		Pubic void actionPerformed(Action e)
		{
			System.out.pringln(“Clicked! N =” +n);
		}
	}
      ActionListener ac = new ActionListener() 
      
      
      Jbutton button = new Jbutton(“Click me”);
      button.addActionListener(ac);
}

Public void foo()
{
	final int n = 1;
      Jbutton button = new Jbutton(“Click me”);
      button.addActionListener(new ActionListener() 
				{
					Pubic void actionPerformed(Action e)
					{
						System.out.pringln(“Clicked! N =” +n);
					}
			});
}

Public void foo()
{
      final int n = 1;
      Jbutton button = new Jbutton(“Click me”);
      button.addActionListener(  ()-> System.out.pringln(“Clicked! N =” +n);
			      );
} 

          //대리자 선언
          public delegate void SayHandler(string mag);
                
            [1]익명메서드 : Say 함수를 작성하지 않고 익명메서드로 작성
            SayHandler hi = delegate(string msg)
            {
                Console.WriteLine(msg);
            };
            hi("익명메서드");

            //[2]익명메서드 : Button의 click event를 익명 메서드로 작성
            Button button = new Button();
            button.Click += delegate(string msg) 
            {
                Console.WriteLine(msg);
            };
            button.OnClick("이벤트 익명메서드");


            //[3]람다표현식 : Button의 click event를 Ramda 표현식으로 작성
            Button button1 = new Button();
            button1.Click += (string msg) => Console.WriteLine(msg);
 
            button.OnClick("람다 표현식");
           
            

스칼라에서 함수표현 

def max(m: Int, n: Int): Int = if(m > n) m else n

스칼라에서의 람다식

1) 보통 

def bubbleSort(arr: Array[Int], order: (Int, Int) => Boolean): Unit {
    ...
    val o: Boolean = order(a, b)
    ...
}

val arr: Array[Int] = Array(2, 5, 1, 7, 8)
bubbleSort(arr, (a: Int, b: Int) => a > b)

2) 짧게 
val arr = Array(2, 5, 1, 7, 8)
bubbleSort(arr, (a, b) => a > b)


3) 더 짧게
val arr = Array(2, 5, 1, 7, 8)
bubbleSort(arr, (_: Int) > (_: Int))

4) 가장 짧게
val arr = Array(2, 5, 1, 7, 8)
bubbleSort(arr, _ > _)

JAVA8  ) 
List names = Arrays.asList("1", "2", "3");
Stream lengths = names.stream().map(name -> name.length());

Scala ) 
val names = List("1", "2", "3")
val lengths = names.map(name => name.length)



JAVA8  )
List<Photo> photos = Arrays.asList(...)
List<Photo> output = photos.filter(p -> p.getSizeInKb() < 10)

Scala ) 
val photos = List(...)
val output = photos.filter(p => p.sizeKb < 10)

function applyOperation(a, b, operation) 
{
  return operation(a,b);
}

function add(a,b) { return a+ b; }

applyOperation(1,2, add);


// anonymous inline function
applyOperation(4,7, function(a,b) {return a * b})

class Array
  def iterate!(code)
    self.each_with_index do |n, i|
      self[i] = code.call(n)
    end
  end
end

array = [1, 2, 3, 4]

array.iterate!(lambda { |n| n ** 2 })

puts array.inspect

# => [1, 4, 9, 16]

int count = 0;
for(String w : words){
   if (w.length > 12 ) count++;
}

long count = words.stream().filter( w -> w.length() > 12 ).count();

long count = words.parallelStream().filter ( w -> w.length() > 12).count()

public class TestServer implements RPCProtocol {

Class  cls  = Class.forName(“RPCProtocol“);

Class paramTypes[] = new Class[2];
pramTypes[0] = String.TYPE;
pramTypes[2] = Integer.TYPE;

Method meth = cls.getMethod(“heartbeat”, paramTypes);

Object arglist[] = new Object[2];
arglist[0] = new String(“hello world”)
arglist[1] = new Integer(2);


RPCProtocol rp  =  new  TestServer ();

Object retObj = meth.invoke(rp, arglist);

Integer retval = (Integer) retObj;

중요포인트 ( 필요사항 ) :    실제 객체 /  클래스타입 /  메소드이름 /  인자타입 / 실제 인자 /    

Hadoop  에서 각각에 대한 변수명 

                     instance (실제객체) 
                     protocol   (클래스타입) 
                     Invoocation  ( 메소드이름, 인자클래스, 실제 인자값)

public class MyDebugInvocationHandler   implements java.lang.reflect.InvocationHandler {    
        private Object target = null;
          public void setTarget(Object target_) {
            this.target = target_;
        }
        
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("Going to execute method : " + method.getName);
                Object retObject = method.invoke(target, args);
                System.out.println("After execute method : " + method.getName());
                return retObject;
        }
    }


-----------


 IMyBusinessObject bo = new MyBusinessObject(); // 실제 비즈니스 객체
  MyDebugInvocationHandler aMyDebugInvocationHandler = new MyDebugInvocationHandler();
  aMyDebugInvocationHandler.setTarget(bo);
    
 IMyBusinessObject proxyObject =    (IMyBusinessObject) Proxy.newProxyInstance  // 프록시 객체 생성
          (IMyBusinessObject.class.getClassLoader(),
          new Class[] { IMyBusinessObject.class }, // 프록시할 인터페이스
          aMyDebugInvocationHandler); // InvocationHandler
    
    // 프록시 객체 사용
    System.out.println(proxyObject.doExecute("Hello World"));

* InputStream / OutputStream
* Selctor
* Channel
* ByteBuffer
* Socket

DFSClient

(ClientProtocol)RPC.getProxy(ClientProtocol.class,
        ClientProtocol.versionID, nameNodeAddr, ugi, conf,
        NetUtils.getSocketFactory(conf, ClientProtocol.class), 0,..)

 this.namenode = createNamenode(this.rpcNamenode, conf);
 
 namenode.getBlockLocations(src, start, length);

1)
   final Invoker invoker = new Invoker(protocol, addr, ticket, conf, factory,
        rpcTimeout, connectionRetryPolicy);
    VersionedProtocol proxy = (VersionedProtocol)Proxy.newProxyInstance(
        protocol.getClassLoader(), new Class[]{protocol}, invoker);

2)

  private static class Invoker implements InvocationHandler {
    private Client.ConnectionId remoteId;
    private Client client;
   
    private Invoker(Class<? extends VersionedProtocol> protocol,
                     InetSocketAddress address, 
                     UserGroupInformation ticket,
                     Configuration conf, 
                     SocketFactory factory,
                     int rpcTimeout, 
                     RetryPolicy connectionRetryPolicy) throws IOException {
   
       this.remoteId = Client.ConnectionId.getConnectionId(address, protocol,
          ticket, rpcTimeout, connectionRetryPolicy, conf);
       this.client = CLIENTS.getClient(conf, factory);
    }

    public Object invoke(Object proxy, Method method, Object[] args)
      throws Throwable {
    
      ObjectWritable value = (ObjectWritable)
        client.call(new Invocation(method, args), remoteId);
     
      return value.get();
    }

public Writable call(Writable param, ConnectionId remoteId)  
                       throws InterruptedException, IOException {
    Call call = new Call(param);
    Connection connection = getConnection(remoteId, call);
    connection.sendParam(call);                 // send the parameter

public class NameNode implements ClientProtocol, DatanodeProtocol,

   this.server = RPC.getServer(this, socAddr.getHostName(),
        socAddr.getPort(), handlerCount, false, conf, namesystem
        .getDelegationTokenSecretManager());

public static Server getServer(...){    
      return new Server(instance, conf, bindAddress, port, numHandlers, verbose, secretManager);
  }

 public static class Server extends org.apache.hadoop.ipc.Server {

  public Writable call(Class<?> protocol, Writable param, long receivedTime) 
        Invocation call = (Invocation)param;
        if (verbose) log("Call: " + call);

        Method method =
          protocol.getMethod(call.getMethodName(),
                                   call.getParameterClasses());
        method.setAccessible(true);

        long startTime = System.currentTimeMillis();
        Object value = method.invoke(instance, call.getParameters());

 Server
   listener = new Listener();
  
 Listener 
      void doAccept(SelectionKey key) 

  Reader 
    void doRead(SelectionKey key) 

  Connection 
         public int readAndProcess() 
         private void processData(byte[] buf) 
   
  Call 
  call = new Call(id, param, this); 
  callQueue.put(call); // queue the call; 

  Handler 
    final Call call = callQueue.take(); // pop the queue; 
    value = call(call.connection.protocol, call.param, call.timestamp); 

 Response

 Invocation call = (Invocation)param;
        
 Method method = protocol.getMethod(call.getMethodName(),call.getParameterClasses());
      
 Object value = method.invoke(instance, call.getParameters());