#include <iostream>
using namespace std;

class CComplexObject // a demo class
{
  public:
      void clone() { cout << "in clone" << endl; }
};

// Solving the problem of choosing method to call by inner traits class
template <typename T, bool isClonable>
class XContainer
{
  public:
      enum {Clonable = isClonable};

      void clone(T* pObj)
      {
          Traits<isClonable>().clone(pObj);
      }

      template <bool flag>
          class Traits
          {
          };

      template <>
          class Traits<true>
          {
              public:
                  void clone(T* pObj)
                  {
                      cout << "before cloning Clonable type" << endl;
                      pObj->clone();
                      cout << "after cloning Clonable type" << endl;
                  }
          };

      template <>
          class Traits<false>
          {
              public:
                  void clone(T* pObj)
                  {
                      cout << "cloning non Clonable type" << endl;
                  }
          };
};

void main()
{
  int* p1 = 0;
  CComplexObject* p2 = 0;

  XContainer<int, false> n1;
  XContainer<CComplexObject, true> n2;

  n1.clone(p1);
  n2.clone(p2);
}

#ifndef MY_TYPE_TRAITS_H
#define MY_TYPE_TRAITS_H

struct my_true_type {
};

struct my_false_type {
};

template <class T>
struct my_type_traits
{
  typedef my_false_type has_trivial_destructor;
};

template<> struct my_type_traits<int>
{
  typedef my_true_type has_trivial_destructor;
};

#endif

#ifndef MY_DESTRUCT_H
#define MY_DESTRUCT_H
#include <iostream>

#include "my_type_traits.h"

using std::cout;
using std::endl;

  template <class T1, class T2>
inline void myconstruct(T1 *p, const T2& value)
{
  new (p) T1(value);
}

  template <class T>
inline void mydestroy(T *p)
{
  typedef typename my_type_traits<T>::has_trivial_destructor trivial_destructor;
  _mydestroy(p, trivial_destructor());
}

  template <class T>
inline void _mydestroy(T *p, my_true_type)
{
  cout << " do the trivial destructor " << endl;
}

  template <class T>
inline void _mydestroy(T *p, my_false_type)
{
  cout << " do the real destructor " << endl;
  p->~T();
}

#endif

#include <iostream>
#include "my_destruct.h"

using std::cout;
using std::endl;

class TestClass
{
  public:
      TestClass()
      {
          cout << "TestClass constructor call" << endl;
          data = new int(3);
      }
      TestClass(const TestClass& test_class)
      {
          cout << "TestClass copy constructor call. copy data:"
              << *(test_class.data) << endl;
          data = new int;
          *data = *(test_class.data) * 2;
      }
      ~TestClass()
      {
          cout << "TestClass destructor call. delete the data:" << *data << endl;
          delete data;
      }
  private:
      int *data;
};

int main(void)
{
  {
      TestClass *test_class_buf;
      TestClass test_class;

      test_class_buf = (TestClass *)malloc(sizeof(TestClass));
      myconstruct(test_class_buf, test_class);
      mydestroy(test_class_buf);
      free(test_class_buf);
  }

  {
      int *int_p;
      int_p = new int;
      mydestroy(int_p);
      free(int_p);
  }
}

template <typename T>
class myIterator
{
   ...
};

template <typename T>
class myIterator
{
        typedef  T value_type;
        ...
};

template <typename T>
typename myIterator<T>::value_type Foo(myIterator<T> i)
{
   ...
}

template <typename I> //这里的I可以是任意类型的迭代器
typename I::value_type Foo(I i)
{
   ...
}

template <typename T>
class Traits
{
        typedef typename T::value_type value_type;
};

template <typename I> //这里的I可以是任意类型的迭代器
typename Traits<I>::value_type Foo(I i)
{
   ...
}

template <typename T>
class Traits<T*> //注意 这里针对原生指针进行了偏特化
{
        typedef typename T value_type;
};

int * p;
....
int i = Foo(p);

$tools/clang/scripts/update.sh

$./build/gyp_chromium
$make chrome -j4

$GYP_GENERATORS=ninja GYP_DEFINES=clang=1 ./build/gyp_chromium
$ninja -C out/Debug chrome #fast

$GYP_GENERATORS=make GYP_DEFINES=clang=1 ./build/gyp_chromium
$make chrome -j4  # 4: Number of cores, change accordingly

download_nacl_toolchain.py  timeout

LASTCHANGE is needed

solutions = [
{ "name"        : "src",
  "url"         : "https://src.chromium.org/chrome/trunk/src",
  "deps_file"   : "DEPS",
  "managed"     : True,
  "custom_deps" : {
      "src/third_party/WebKit/LayoutTests": None,
      "src/content/test/data/layout_tests/LayoutTests": None,
      "src/chrome_frame/tools/test/reference_build/chrome": None,
      "src/chrome_frame/tools/test/reference_build/chrome_win": None,
      "src/chrome/tools/test/reference_build/chrome": None,
      "src/chrome/tools/test/reference_build/chrome_linux": None,
      "src/chrome/tools/test/reference_build/chrome_mac": None,
      "src/chrome/tools/test/reference_build/chrome_win": None,
  },
  "safesync_url": "",
},
  ]

#include <boost/algorithm/string.hpp>

using namespace boost;

int main()
{
  string s = "a,b, c ,,e,f,";
  vector <string> fields;
  split( fields, s, is_any_of( "," ) );
  }

string s = "one->two->thirty-four";
vector <string> fields;
split_regex( fields, s, regex( "->" ) );

const char* s = ",,three,,five,,";
char** fields = g_strsplit( s, ',', 0 );
for (char** field = fields; field; ++field, ++n)
{
  printf( "\"%s\"\n", *field );
}
g_strfreev( fields );
fields = NULL;

string s = "string, to, split";
istringstream ss( s );
while (!ss.eof())
{
    string x;               // here's a nice, empty string
      getline( ss, x, ',' );  // try to read the next field into it
        cout << x << endl;      // print it out, even if we already hit EOF
}

string s = "string, to, split";
string delimiters = " ,";
size_t current;
size_t next = -1;
do
{
    current = next + 1;
      next = s.find_first_of( delimiters, current );
        cout << s.substr( current, next - current ) << endl;
}
while (next != string::npos);

string s=abcdeabcdeabcde;
string[] sArray=s.Split('c') ;
foreach(string i in sArray)
Console.WriteLine(i.ToString());

string s="abcdeabcdeabcde";
string[] sArray1=s.Split(new char[3]{'c','d','e'}) ;
foreach(string i in sArray1)
Console.WriteLine(i.ToString());

string content=agcsmallmacsmallgggsmallytx;
string[]resultString=Regex.Split(content,small,RegexOptions.IgnoreCase)
foreach(string i in resultString)
Console.WriteLine(i.ToString());

str = 'a,b,c,d'
strlist = str.split(',') # 用逗号分割str字符串，并保存到列表

def handler_request(self, request):

    answ = self.remote_server.query(request) # this takes 5 seconds

      request.write_response(answ)

def handler_request(self, request):

    self.remote_server.query_async(request, self.response_received)



  def response_received(self, request, answ):    # this is called 5 seconds later

      request.write(answ)

$sudo easy_install tornado

git clone http://github.com/facebook/tornado.git
cd tornado
sudo python setup.py install

def add_handler(self, fd, handler, events):

    """Registers the given handler to receive the given events for fd."""

      self._handlers[fd] = handler

          self._impl.register(fd, events | self.ERROR)

def start(self):

  """Starts the I/O loop.



 The loop will run until one of the I/O handlers calls stop(), which

 will make the loop stop after the current event iteration completes.

 """

  self._running = True

  while True:



  [ ... ]



  if not self._running:

  break



  [ ... ]



  try:

event_pairs = self._impl.poll(poll_timeout)

  except Exception, e:

  if e.args == (4, "Interrupted system call"):

  logging.warning("Interrupted system call", exc_info=1)

  continue

  else:

  raise



# Pop one fd at a time from the set of pending fds and run

# its handler. Since that handler may perform actions on

# other file descriptors, there may be reentrant calls to

# this IOLoop that update self._events

self._events.update(event_pairs)

  while self._events:

fd, events = self._events.popitem()

  try:

self._handlers[fd](fd, events)

  except KeyboardInterrupt:

  raise

  except OSError, e:

  if e[0] == errno.EPIPE:

# Happens when the client closes the connection

  pass

  else:

  logging.error("Exception in I/O handler for fd %d",

          fd, exc_info=True)

  except:

  logging.error("Exception in I/O handler for fd %d",

          fd, exc_info=True)

def __init__(self, impl=None):



  [...]



  # Create a pipe that we send bogus data to when we want to wake

  # the I/O loop when it is idle

  r, w = os.pipe()

  self._set_nonblocking(r)

  self._set_nonblocking(w)

  self._waker_reader = os.fdopen(r, "r", 0)

  self._waker_writer = os.fdopen(w, "w", 0)

  self.add_handler(r, self._read_waker, self.WRITE)





def _wake(self):

  try:

      self._waker_writer.write("x")

  except IOError:

      pass

def add_timeout(self, deadline, callback):

  """Calls the given callback at the time deadline from the I/O loop."""

  timeout = _Timeout(deadline, callback)

  bisect.insort(self._timeouts, timeout)

  return timeout

def listen(self, port, address=""):

    assert not self._socket

  self._socket = socket.(socket.AF_INET, socket.SOCK_STREAM, 0)

  flags = fcntl.fcntl(self._socket.fileno(), fcntl.F_GETFD)

  flags |= fcntl.FD_CLOEXEC

  fcntl.fcntl(self._socket.fileno(), fcntl.F_SETFD, flags)

  self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

  self._socket.setblocking(0)

  self._socket.bind((address, port))

  self._socket.listen(128)

  self.io_loop.add_handler(self._socket.fileno(), self._handle_events,

  self.io_loop.READ)

def _handle_events(self, fd, events):

    while True:

  try:

connection, address = self._socket.accept()

  except socket.error, e:

  if e[0] in (errno.EWOULDBLOCK, errno.EAGAIN):

      return

      raise

      try:

stream = iostream.IOStream(connection, io_loop=self.io_loop)

  HTTPConnection(stream, address, self.request_callback,

          self.no_keep_alive, self.xheaders)

  except:

  logging.error("Error in connection callback", exc_info=True)

#include <string.h>
#include <errno.h>

#include "zookeeper.h"

static zhandle_t *zh;

/**
 * In this example this method gets the cert for your
 *   environment -- you must provide
 */
char *foo_get_cert_once(char* id) { return 0; }

/** Watcher function -- empty for this example, not something you should
 * do in real code */
void watcher(zhandle_t *zzh, int type, int state, const char *path,
      void *watcherCtx) {}

int main(int argc, char argv) {
  char buffer[512];
  char p[2048];
  char *cert=0;
  char appId[64];

  strcpy(appId, "example.foo_test");
  cert = foo_get_cert_once(appId);
  if(cert!=0) {
      fprintf(stderr,
              "Certificate for appid [%s] is [%s]\n",appId,cert);
      strncpy(p,cert, sizeof(p)-1);
      free(cert);
  } else {
      fprintf(stderr, "Certificate for appid [%s] not found\n",appId);
      strcpy(p, "dummy");
  }

  zoo_set_debug_level(ZOO_LOG_LEVEL_DEBUG);

  zh = zookeeper_init("localhost:3181", watcher, 10000, 0, 0, 0);
  if (!zh) {
      return errno;
  }
  if(zoo_add_auth(zh,"foo",p,strlen(p),0,0)!=ZOK)
      return 2;

  struct ACL CREATE_ONLY_ACL[] = ;
  struct ACL_vector CREATE_ONLY = {1, CREATE_ONLY_ACL};
  int rc = zoo_create(zh,"/xyz","value", 5, &CREATE_ONLY, ZOO_EPHEMERAL,
          buffer, sizeof(buffer)-1);

  /** this operation will fail with a ZNOAUTH error */
  int buflen= sizeof(buffer);
  struct Stat stat;
  rc = zoo_get(zh, "/xyz", 0, buffer, &buflen, &stat);
  if (rc) {
      fprintf(stderr, "Error %d for %s\n", rc, __LINE__);
  }

  zookeeper_close(zh);
  return 0;
}

/**
 * A simple example program to use DataMonitor to start and
 * stop executables based on a znode. The program watches the
 * specified znode and saves the data that corresponds to the
 * znode in the filesystem. It also starts the specified program
 * with the specified arguments when the znode exists and kills
 * the program if the znode goes away.
 */
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;

public class Executor
implements Watcher, Runnable, DataMonitor.DataMonitorListener
{
  String znode;

  DataMonitor dm;

  ZooKeeper zk;

  String filename;

  String exec[];

  Process child;

  public Executor(String hostPort, String znode, String filename,
          String exec[]) throws KeeperException, IOException {
      this.filename = filename;
      this.exec = exec;
      zk = new ZooKeeper(hostPort, 3000, this);
      dm = new DataMonitor(zk, znode, null, this);
  }

  /**
  * @param args
  */
  public static void main(String[] args) {
      if (args.length < 4) {
          System.err
              .println("USAGE: Executor hostPort znode filename program [args ...]");
          System.exit(2);
      }
      String hostPort = args[0];
      String znode = args[1];
      String filename = args[2];
      String exec[] = new String[args.length - 3];
      System.arraycopy(args, 3, exec, 0, exec.length);
      try {
          new Executor(hostPort, znode, filename, exec).run();
      } catch (Exception e) {
          e.printStackTrace();
      }
  }

  /***************************************************************************
  * We do process any events ourselves, we just need to forward them on.
  *
  * @see org.apache.zookeeper.Watcher#process(org.apache.zookeeper.proto.WatcherEvent)
  */
  public void process(WatchedEvent event) {
      dm.process(event);
  }

  public void run() {
      try {
          synchronized (this) {
              while (!dm.dead) {
                  wait();
              }
          }
      } catch (InterruptedException e) {
      }
  }

  public void closing(int rc) {
      synchronized (this) {
          notifyAll();
      }
  }

  static class StreamWriter extends Thread {
      OutputStream os;

      InputStream is;

      StreamWriter(InputStream is, OutputStream os) {
          this.is = is;
          this.os = os;
          start();
      }

      public void run() {
          byte b[] = new byte[80];
          int rc;
          try {
              while ((rc = is.read(b)) > 0) {
                  os.write(b, 0, rc);
              }
          } catch (IOException e) {
          }

      }
  }

  public void exists(byte[] data) {
      if (data == null) {
          if (child != null) {
              System.out.println("Killing process");
              child.destroy();
              try {
                  child.waitFor();
              } catch (InterruptedException e) {
              }
          }
          child = null;
      } else {
          if (child != null) {
              System.out.println("Stopping child");
              child.destroy();
              try {
                  child.waitFor();
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
          }
          try {
              FileOutputStream fos = new FileOutputStream(filename);
              fos.write(data);
              fos.close();
          } catch (IOException e) {
              e.printStackTrace();
          }
          try {
              System.out.println("Starting child");
              child = Runtime.getRuntime().exec(exec);
              new StreamWriter(child.getInputStream(), System.out);
              new StreamWriter(child.getErrorStream(), System.err);
          } catch (IOException e) {
              e.printStackTrace();
          }
      }
  }
}

/**
 * A simple class that monitors the data and existence of a ZooKeeper
 * node. It uses asynchronous ZooKeeper APIs.
 */
import java.util.Arrays;

import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.AsyncCallback.StatCallback;
import org.apache.zookeeper.KeeperException.Code;
import org.apache.zookeeper.data.Stat;

public class DataMonitor implements Watcher, StatCallback {

  ZooKeeper zk;

  String znode;

  Watcher chainedWatcher;

  boolean dead;

  DataMonitorListener listener;

  byte prevData[];

  public DataMonitor(ZooKeeper zk, String znode, Watcher chainedWatcher,
          DataMonitorListener listener) {
      this.zk = zk;
      this.znode = znode;
      this.chainedWatcher = chainedWatcher;
      this.listener = listener;
      // Get things started by checking if the node exists. We are going
      // to be completely event driven
      zk.exists(znode, true, this, null);
  }

  /**
  * Other classes use the DataMonitor by implementing this method
  */
  public interface DataMonitorListener {
      /**
      * The existence status of the node has changed.
      */
      void exists(byte data[]);

      /**
      * The ZooKeeper session is no longer valid.
      *
      * @param rc
      *                the ZooKeeper reason code
      */
      void closing(int rc);
  }

  public void process(WatchedEvent event) {
      String path = event.getPath();
      if (event.getType() == Event.EventType.None) {
          // We are are being told that the state of the
          // connection has changed
          switch (event.getState()) {
              case SyncConnected:
                  // In this particular example we don't need to do anything
                  // here - watches are automatically re-registered with 
                  // server and any watches triggered while the client was 
                  // disconnected will be delivered (in order of course)
                  break;
              case Expired:
                  // It's all over
                  dead = true;
                  listener.closing(KeeperException.Code.SessionExpired);
                  break;
          }
      } else {
          if (path != null && path.equals(znode)) {
              // Something has changed on the node, let's find out
              zk.exists(znode, true, this, null);
          }
      }
      if (chainedWatcher != null) {
          chainedWatcher.process(event);
      }
  }

  public void processResult(int rc, String path, Object ctx, Stat stat) {
      boolean exists;
      switch (rc) {
          case Code.Ok:
              exists = true;
              break;
          case Code.NoNode:
              exists = false;
              break;
          case Code.SessionExpired:
          case Code.NoAuth:
              dead = true;
              listener.closing(rc);
              return;
          default:
              // Retry errors
              zk.exists(znode, true, this, null);
              return;
      }

      byte b[] = null;
      if (exists) {
          try {
              b = zk.getData(znode, false, null);
          } catch (KeeperException e) {
              // We don't need to worry about recovering now. The watch
              // callbacks will kick off any exception handling
              e.printStackTrace();
          } catch (InterruptedException e) {
              return;
          }
      }
      if ((b == null && b != prevData)
              || (b != null && !Arrays.equals(prevData, b))) {
          listener.exists(b);
          prevData = b;
      }
  }
}