1 #!/usr/local/bin/thrift -cpp -java -py -php -rb -perl -erl -xsd -r
4 # Mark Slee (mcslee@facebook.com)
6 # This file aims to teach you how to use Thrift, in a .thrift file. Neato. The
7 # first thing to notice is that .thrift files support standard shell comments.
8 # This lets you make your thrift file executable and include your Thrift build
9 # step on the top line. And you can place comments like this anywhere you like.
11 # Before running this file, you will need to have installed the thrift compiler
12 # into /usr/local/bin.
15 * The first thing to know about are types. The available types in Thrift are:
17 * bool Boolean, one byte
19 * i16 Signed 16-bit integer
20 * i32 Signed 32-bit integer
21 * i64 Signed 64-bit integer
22 * double 64-bit floating point value
24 * map<t1,t2> Map from one type to another
25 * list<t1> Ordered list of one type
26 * set<t1> Set of unique elements of one type
28 * Did you also notice that Thrift supports C style comments?
31 // Just in case you were wondering... yes. We support simple C comments too.
34 * Thrift files can reference other Thrift files to include common struct
35 * and service definitions. These are found using the current path, or by
36 * searching relative to any paths specified with the -I compiler flag.
38 * Included objects are accessed using the name of the .thrift file as a
39 * prefix. i.e. shared.SharedObject
41 include "shared.thrift"
44 * Thrift files can namespace, package, or prefix their output in various
47 cpp_namespace tutorial
49 php_namespace tutorial
53 * Thrift lets you do typedefs to get pretty names for your types. Standard
59 * Thrift also lets you define constants for use across languages. Complex
60 * types and structs are specified using JSON notation.
62 const i32 INT32CONSTANT = 9853
63 const map<string,string> MAPCONSTANT = {'hello':'world', 'goodnight':'moon'}
66 * You can define enums, which are just 32 bit integers. Values are optional
67 * and start at 1 if not supplied, C style again.
77 * Structs are the basic complex data structures. They are comprised of fields
78 * which each have an integer identifier, a type, a symbolic name, and an
79 * optional default value.
88 * Structs can also be exceptions, if they are nasty.
90 exception InvalidOperation {
96 * Ahh, now onto the cool part, defining a service. Services just need a name
97 * and can optionally inherit from another service using the extends keyword.
99 service Calculator extends shared.SharedService {
102 * A method definition looks like C code. It has a return type, arguments,
103 * and optionally a list of exceptions that it may throw. Note that argument
104 * lists and exception lists are specified using the exact same syntax as
105 * field lists in struct or exception definitions.
110 i32 add(1:i32 num1, 2:i32 num2),
112 i32 calculate(1:i32 logid, 2:Work w) throws (1:InvalidOperation ouch),
115 * This method has an async modifier. That means the client only makes
116 * a request and does not listen for any response at all. Async methods
124 * That just about covers the basics. Take a look in the test/ folder for more
125 * detailed examples. After you run this file, your generated code shows up
126 * in folders with names gen-<language>. The generated code isn't too scary
127 * to look at. It even has pretty indentation.