code: function parse(point){
      var parts = point.split(' ');
  
      var measurement,
          tags = parts[0] || '',
          fields = parts[1] || '',
          timestamp = parts[2];
  
      function splitColon(str){
          str = str || '';
          str = str.replace(/\\/m, '#c#');
          str = str.split(',');
          str.map(function(s){
              return s.replace(/#c#/gm, ',');
          });
          return str;
      }
      tags = splitColon(tags);
      fields = splitColon(fields);
  
      measurement = tags.shift();
  
      var key, value;
      tags = tags.map(function(tag){
          key = tag.split('=')[0];
          value = tag.split('=')[1];
          var out = {};
          out[key] = value;
          return out;
      });
      tags = tags.filter(function(x){
          return x !== undefined;
      });
  
      fields = fields.map(function(field){
          if(!field) return undefined;
          key = field.split('=')[0];
          value = field.split('=')[1];
          var out = {};
          out[key] = cast(value);
          return out;
      });
      fields = fields.filter(function(x){
          return x !== undefined;
      });
  
      if(timestamp){
          timestamp = parseInt(timestamp);
      }
  
      var out = {
          timestamp: timestamp,
          measurement: measurement,
          fields: fields,
          tags: tags
      };
  
      if(!timestamp) delete out.timestamp;
  
      return out;
  }
docs: Actual parsing of line protocol
  
  We have to review how we do parsing in
  order to perperly handle non normalized
  names or values- i.e. names with commas or
  spaces in them or values with spaces in them.
  
  We could extract all key/pair values from
  a string, and then we are left with the
  measurement...
  ```
  ([a-zA-Z-\s]+=[a-zA-Z-\s]+)
  ```
  
  @param  {string} point Point in line protcol
  @return {object}       Parsed object