google probuf源码分析之descriptor

要把这个文件里所有变量和函数都看懂

1.讲字符串转为驼峰命名法：

string ToCamelCase(const string& input) {
  bool capitalize_next = false;
  string result;
  result.reserve(input.size());

  for (int i = 0; i < input.size(); i++) {
    if (input[i] == '_') {
      capitalize_next = true;
    } else if (capitalize_next) {
      // Note:  I distrust ctype.h due to locales.
      if ('a' <= input[i] && input[i] <= 'z') {
        result.push_back(input[i] - 'a' + 'A');
      } else {
        result.push_back(input[i]);
      }
      capitalize_next = false;
    } else {
      result.push_back(input[i]);
    }
  }

  // Lower-case the first letter.
  if (!result.empty() && 'A' <= result[0] && result[0] <= 'Z') {
    result[0] = result[0] - 'A' + 'a';
  }

  return result;
}

算法很简单：搞了一个vec来存档结果，遇到_就停下，把后面一个字符转为大写，最后检查第一个字符并转为小写。

比如we_aer_eyye_eee转为weAerEyyeEee；

2.hashmap的key扩展，关于原因，注释里写的很清楚

// A DescriptorPool contains a bunch of hash_maps to implement the
// various Find*By*() methods.  Since hashtable lookups are O(1), it's
// most efficient to construct a fixed set of large hash_maps used by
// all objects in the pool rather than construct one or more small
// hash_maps for each object.
//
// The keys to these hash_maps are (parent, name) or (parent, number)
// pairs.  Unfortunately STL doesn't provide hash functions for pair<>,
// so we must invent our own.
主要是有key可以是是一个pair，查询的时候可以这个pair，下面看看如何实现的嘛。

看了半天，貌似不怎么清晰，还是自己搞了个std::hash_map的key为pair的东东。

#include "stdio.h"
#include "Product.h"
#include "ProductConcurrentQueue.h"
#include "ProductQueue.h"
#include <windows.h>

#include <string>
#include <iostream>
#include <hash_map>

using namespace std;


typedef pair<const char*, const char*> PointerStringPair;

size_t SDBMHash(const char *str)
{
	size_t hash = 0;

	char* tst = (char*)(str);
	while (*tst)
	{
		// equivalent to: hash = 65599*hash + (*str++);
		hash = (*tst++) + (hash << 6) + (hash << 16) - hash;
	}

	return (hash & 0x7FFFFFFF);
}
inline size_t PointerStringPair_hash_value(const PointerStringPair& aPair) 
{ 
	return SDBMHash(aPair.first) + SDBMHash(aPair.second);
}

class PointerStringPair_hash_compare : public hash_compare<PointerStringPair> 
{ 
public: 
	size_t operator()(const PointerStringPair& _Key) const 
	{ 
		return((size_t)PointerStringPair_hash_value(_Key));
	}

	bool operator()(const PointerStringPair& _Keyval1, const PointerStringPair& _Keyval2) const 
	{ 
		return strcmp(_Keyval1.first, _Keyval2.first) != 0
			&& strcmp(_Keyval1.second, _Keyval2.second) != 0 ;
	} 
};
typedef hash_map<PointerStringPair, int, PointerStringPair_hash_compare> FieldsByNameMap;

int main()
{
	string str1("11");
	string str2("12");
	PointerStringPair lkey1(str1.c_str(), str2.c_str());
	FieldsByNameMap lMap;
	
	lMap.insert(std::make_pair(lkey1,1));

	PointerStringPair lkey2("12", "13");
	lMap.insert(std::make_pair(lkey2,2));

	for (FieldsByNameMap::iterator iter = lMap.begin();
		iter != lMap.end(); ++iter)
	{
		PointerStringPair pair = iter->first;
		printf("first: %s %s %d\n", pair.first,pair.second, iter->second);
	}
	
	FieldsByNameMap::iterator iter = lMap.find(lkey1);
	if (iter != lMap.end())
	{
		printf("res:%d\n", iter->second);
	}
	
}

这个很完整，连测试代码都有啦，嘎嘎！

明白原理就整下一步。

我们看下DescriptorPool这个重要的类是怎么加载的：

看了半天找不到头绪，猛然看到一个注释：

void DescriptorPool::InternalAddGeneratedFile(
    const void* encoded_file_descriptor, int size) {
  InitGeneratedPoolOnce();
  GOOGLE_CHECK(generated_database_->Add(encoded_file_descriptor, size));
}

注释：

  这个函数是在已经产生的proto类初始化descriptors的过程中调用的。每个产生的.pb.cc文件都要一个内部模块AddDescriptors()，它会在过程启动的时候被调用。
 那个函数调用这个函数用来将本类所代表原始FileDescriptorProto进行注册。
 我们实际上不会立即构建descriptor对象。在它实际调用的时候才会构建。第一次被调用才会构建。

之后是各种descriptors的声明和定义。

暂时写到这里。