ridv/gorealis-v2
1
0
Fork 0
Code Issues Pull requests Projects Releases 13 Packages Wiki Activity Actions

Moving from govendor to dep, updated dependencies (#48)

Browse source 
* Moving from govendor to dep.

* Making the pull request template more friendly.

* Fixing akward space in PR template.

* goimports run on whole project using ` goimports -w $(find . -type f -name '*.go' -not -path "./vendor/*" -not -path "./gen-go/*")`

source of command: https://gist.github.com/bgentry/fd1ffef7dbde01857f66
This commit is contained in:
Renan DelValle 2018-01-07 13:13:47 -08:00 • committed by GitHub
parent 9631aa3aab
commit 8d445c1c77
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
2186 changed files with 400410 additions and 352 deletions
Download patch file Download diff file Expand all files Collapse all files

1231
vendor/git.apache.org/thrift.git/lib/ocaml/OCamlMakefile generated vendored Normal file
View file

File diff suppressed because it is too large Load diff

643
vendor/git.apache.org/thrift.git/lib/ocaml/README-OCamlMakefile generated vendored Normal file
View file

@ -0,0 +1,643 @@
NOTE (bryanduxbury): OCamlMakefile is safe to include in the project after
https://issues.apache.org/jira/browse/LEGAL-58.
---------------------------------------------------------------------------
Distribution of "ocaml_make"
Copyright (C) 1999 - 2006 Markus Mottl - free to copy and modify!
USE AT YOUR OWN RISK!
---------------------------------------------------------------------------
PREREQUISITES
*** YOU WILL NEED GNU-MAKE VERSION >3.80 ***
---------------------------------------------------------------------------
Contents of this distribution
Changes - guess what? ;-)
OCamlMakefile - Makefile for easy handling of compilation of not so easy
OCaml-projects. It generates dependencies of OCaml-files
automatically, is able to handle "ocamllex"-,
"ocamlyacc"-, IDL- and C-files, knows how to run
preprocessors and generates native- or byte-code, as
executable or as library - with thread-support if you
want! Profiling and debugging support can be added on
the fly! There is also support for installing libraries.
Ah, yes, and you can also create toplevels from any
sources: this allows you immediate interactive testing.
Automatic generation of documentation is easy due to
integration of support for OCamldoc.
README - this file
calc/ - Directory containing a quite fully-featured example
of what "OCamlMakefile" can do for you. This example
makes use of "ocamllex", "ocamlyacc", IDL + C and
threads.
camlp4/ - This simple example demonstrates how to automatically
preprocess files with the camlp4-preprocessor.
gtk/ - Demonstration of how to use OCamlMakefile with GTK
and threads. Courtesy of Tim Freeman <tim@fungible.com>.
idl/ - Contains a very small example of how to use
"camlidl" together with "OCamlMakefile". Also intended
to show, how easy it is to interface OCaml and C.
threads/ - Two examples of how to use threads (originally
posted by Xavier Leroy some time ago). Shows the use of
"OCamlMakefile" in an environment of multiple compilation
targets.
---------------------------------------------------------------------------
Why should you use it?
For several reasons:
* It is well-tested (I use it in all of my projects).
* In contrast to most other approaches it generates dependencies
correctly by ensuring that all automatically generated OCaml-files
exist before dependency calculation. This is the only way to
guarantee that "ocamldep" works correctly.
* It is extremely convenient (at least I think so ;-).
Even quite complex compilation processes (see example "calc.ml")
need very little information to work correctly - actually just about
the minimum (file names of sources).
---------------------------------------------------------------------------
When you shouldn't use it...
In projects where every compilation unit needs different flags - but
in such complicated cases you will be on your own anyway. Luckily,
this doesn't happen too frequently...
---------------------------------------------------------------------------
How to use "OCamlMakefile" in your own project
(Take a look at the examples for a quick introduction!)
Create your project-specific "Makefile" in the appropriate directory.
Now there are two ways of making use of "OCamlMakefile":
1) Have a look at the default settings in "OCamlMakefile" and set
them to the values that are vaild on your system - whether the
path to the standard libraries is ok, what executables shall be
used, etc...
2) Copy it into the directory of the project to be compiled.
Add "-include OCamlMakefile" as a last line of your "Makefile".
3) Put it somewhere else on the system. In this case you will have to
set a variable "OCAMLMAKEFILE" in your project-specific "Makefile".
This is the way in which the examples are written: so you need
only one version of "OCamlMakefile" to manage all your projects!
See the examples for details.
You should usually specify two further variables for your project:
* SOURCES (default: foo.ml)
* RESULT (default: foo)
Put all the sources necessary for a target into variable "SOURCES".
Then set "RESULT" to the name of the target. If you want to generate
libraries, you should *not* specify the suffix (".cma", ".cmxa", ".a")
- it will be added automatically if you specify that you want to build
a library.
** Don't forget to add the ".mli"-files, too! **
** Don't forget that order of the source files matters! **
The order is important, because it matters during linking anyway
due to potential side effects caused at program startup. This is
why OCamlMakefile does not attempt to partially order dependencies by
itself, which might confuse users even more. It just compiles and links
OCaml-sources in the order specified by the user, even if it could
determine automatically that the order cannot be correct.
The minimum of your "Makefile" looks like this (assuming that
"OCamlMakefile" is in the search path of "make"):
-include OCamlMakefile
This will assume that you want to compile a file "foo.ml" to a binary
"foo".
Otherwise, your Makefile will probably contain something like this:
SOURCES = foo.ml
RESULT = foo
-include OCamlMakefile
Be careful with the names you put into these variables: if they are wrong,
a "make clean" might erase the wrong files - but I know you will not do
that ;-)
A simple "make" will generate a byte-code executable. If you want to
change this, you may add an "all"-rule that generates something else.
E.g.:
SOURCES = foo.ml
RESULT = foo
all: native-code-library
-include OCamlMakefile
This will build a native-code library "foo.cmxa" (+ "foo.a") from file
"foo.ml".
You may even build several targets at once. To produce byte- and native-code
executables with one "make", add the following rule:
all: byte-code native-code
You will probably want to use a different suffix for each of these targets
so that the result will not be overwritten (see optional variables below
for details).
You may also tell "make" at the command-line what kind of target to
produce (e.g. "make nc"). Here all the possibilities with shortcuts
between parenthesis:
* byte-code (bc)
* byte-code-nolink (bcnl) - no linking stage
* byte-code-library (bcl)
* native-code (nc)
* native-code-nolink (ncnl) - no linking stage
* native-code-library (ncl)
* debug-code (dc)
* debug-code-nolink (dcnl) - no linking stage
* debug-code-library (dcl)
* profiling-byte-code (pbc)
* profiling-byte-code-library (pbcl)
* profiling-native-code (pnc)
* profiling-native-code-library (pncl)
* byte-code-dll (bcd)
* native-code-dll (ncd)
* pack-byte-code (pabc)
* pack-native-code (panc)
* toplevel interpreter (top)
* subprojs
Here a short note concerning building and linking byte code libraries
with C-files:
OCaml links C-object files only when they are used in an executable.
After compilation they should be placed in some directory that is in
your include path if you link your library against an executable.
It is sometimes more convenient to link all C-object files into a
single C-library. Then you have to override the automatic link flags
of your library using "-noautolink" and add another linkflag that
links in your C-library explicitly.
What concerns maintenance:
"make clean" removes all (all!) automatically generated files - so
again: make sure your variables are ok!
"make cleanup" is similar to "make clean" but leaves executables.
Another way to destroy some important files is by having "OCamlMakefile"
automatically generate files with the same name. Read the documentation
about the tools in the OCaml-distribution to see what kind of files are
generated. "OCamlMakefile" additionally generates ('%' is basename of
source file):
%_idl.c - "camlidl" generates a file "%.c" from "%.idl", but this is
not such a good idea, because when generating native-code,
both the file "%.c" and "%.ml" would generate files "%.o"
which would overwrite each other. Thus, "OCamlMakefile"
renames "%.c" to "%_idl.c" to work around this problem.
The dependencies are stored in three different subdirectories (dot dirs):
._d - contains dependencies for .ml-files
._bcdi - contains byte code dependencies for .mli-files
._ncdi - contains native code dependencies for .mli-files
The endings of the dependency files are: "%.d" for those generated from
"%.ml"-files, "%.di" for ones derived from "%.mli"-files.
---------------------------------------------------------------------------
Debugging
This is easy: if you discover a bug, just do a "make clean; make dc"
to recompile your project with debugging information. Then you can
immediately apply "ocamldebug" to the executable.
---------------------------------------------------------------------------
Profiling
For generating code that can be profiled with "ocamlprof" (byte code)
or "gprof" (native code), compile your project with one of the profiling
targets (see targets above). E.g.:
* "make pbc" will build byte code that can be profiled with
"ocamlprof".
* "make pnc" will build native code that can be profiled with
"gprof".
Please note that it is not currently possible to profile byte code with
threads. OCamlMakefile will force an error if you try to do this.
A short hint for DEC Alpha-users (under Digital Unix): you may also
compile your sources to native code without any further profiling
options/targets. Then call "pixie my_exec", "my_exec" being your
executable. This will produce (among other files) an executable
"my_exec.pixie". Call it and it will produce profiling information which
can be analysed using "prof -pixie my_exec". The resulting information
is extremely detailed and allows analysis up to the clock cycle level...
---------------------------------------------------------------------------
Using Preprocessors
Because one could employ any kind of program that reads from standard
input and prints to standard output as preprocessor, there cannot be any
default way to handle all of them correctly without further knowledge.
Therefore you have to cooperate a bit with OCamlMakefile to let
preprocessing happen automatically. Basically, this only requires
that you put a comment into the first line of files that should be
preprocessed, e.g.:
(*pp cat *)
... rest of program ...
OCamlMakefile looks at the first line of your files, and if it finds
a comment that starts with "(*pp", then it will assume that the
rest of the comment tells it how to correctly call the appropriate
preprocessor. In this case the program "cat" will be called, which will,
of course, just output the source text again without changing it.
If you are, for example, an advocate of the new "revised syntax",
which is supported by the camlp4 preprocessor, you could simply write:
(*pp camlp4r *)
... rest of program in revised syntax ...
Simple, isn't it?
If you want to write your own syntax extensions, just take a look at the
example in the directory "camlp4": it implements the "repeat ... until"
extension as described in the camlp4-tutorial.
---------------------------------------------------------------------------
Library (Un-)Installation Support
OCamlMakefile contains two targets using "ocamlfind" for this purpose:
* libinstall
* libuninstall
These two targets require the existence of the variable
"LIBINSTALL_FILES", which should be set to all the files that you
want to install in the library directory (usually %.mli, %.cmi, %.cma,
%.cmxa, %.a and possibly further C-libraries). The target "libinstall"
has the dependency "all" to force compilation of the library so make
sure you define target "all" in your Makefile appropriately.
The targets inform the user about the configured install path and ask
for confirmation to (un)install there. If you want to use them, it
is often a good idea to just alias them in your Makefile to "install"
and "uninstall" respectively.
Two other targets allow installation of files into a particular
directory (without using ocamlfind):
* rawinstall
* rawuninstall
---------------------------------------------------------------------------
Building toplevels
There is just one target for this:
* top
The generated file can be used immediately for interactive sessions -
even with scanners, parsers, C-files, etc.!
---------------------------------------------------------------------------
Generating documentation
The following targets are supported:
* htdoc - generates HTML-documentation
* ladoc - generates Latex-documentation
* psdoc - generates PostScript-documentation
* pdfdoc - generates PDF-documentation
* doc - generates all supported forms of documentation
* clean-doc - generates all supported forms of documentation
All of them generate a sub-directory "doc". More precisely, for HTML it
is "doc/$(RESULT)/html" and for Latex, PostScript and PDF the directory
"doc/$(RESULT)/latex". See the OCamldoc-manual for details and the
optional variables below for settings you can control.
---------------------------------------------------------------------------
Handling subprojects
You can have several targets in the same directory and manage them
from within an single Makefile.
Give each subproject a name, e.g. "p1", "p2", etc. Then you export
settings specific to each project by using variables of the form
"PROJ_p1", "PROJ_p2", etc. E.g.:
define PROJ_p1
SOURCES="foo.ml main.ml"
RESULT="p1"
OCAMLFLAGS="-unsafe"
endef
export PROJ_p1
define PROJ_p2
...
endef
export PROJ_p2
You may also export common settings used by all projects directly, e.g.
"export THREADS = y".
Now it is a good idea to define, which projects should be affected by
commands by default. E.g.:
ifndef SUBPROJS
export SUBPROJS = p1 p2
endif
This will automatically generate a given target for all those
subprojects if this variable has not been defined in the shell
environment or in the command line of the make-invocation by the user.
E.g., "make dc" will generate debug code for all subprojects.
Then you need to define a default action for your subprojects if "make"
has been called without arguments:
all: bc
This will build byte code by default for all subprojects.
Finally, you'll have to define a catch-all target that uses the target
provided by the user for all subprojects. Just add (assuming that
OCAMLMAKEFILE has been defined appropriately):
%:
@make -f $(OCAMLMAKEFILE) subprojs SUBTARGET=$@
See the "threads"-directory in the distribution for a short example!
---------------------------------------------------------------------------
Optional variables that may be passed to "OCamlMakefile"
* LIB_PACK_NAME - packs all modules of a library into a module whose
name is given in variable "LIB_PACK_NAME".
* RES_CLIB_SUF - when building a library that contains C-stubs, this
variable controls the suffix appended to the name
of the C-library (default: "_stubs").
* THREADS - say "THREADS = yes" if you need thread support compiled in,
otherwise leave it away.
* VMTHREADS - say "VMTHREADS = yes" if you want to force VM-level
scheduling of threads (byte-code only).
* ANNOTATE - say "ANNOTATE = yes" to generate type annotation files
(.annot) to support displaying of type information
in editors.
* USE_CAMLP4 - say "USE_CAMLP4 = yes" in your "Makefile" if you
want to include the camlp4 directory during the
build process, otherwise leave it away.
* INCDIRS - directories that should be searched for ".cmi"- and
".cmo"-files. You need not write "-I ..." - just the
plain names.
* LIBDIRS - directories that should be searched for libraries
Also just put the plain paths into this variable
* EXTLIBDIRS - Same as "LIBDIRS", but paths in this variable are
also added to the binary via the "-R"-flag so that
dynamic libraries in non-standard places can be found.
* RESULTDEPS - Targets on which results (executables or libraries)
should additionally depend.
* PACKS - adds packages under control of "findlib".
* PREDS - specifies "findlib"-predicates.
* LIBS - OCaml-libraries that should be linked (just plain names).
E.g. if you want to link the Str-library, just write
"str" (without quotes).
The new OCaml-compiler handles libraries in such
a way that they "remember" whether they have to
be linked against a C-library and it gets linked
in automatically.
If there is a slash in the library name (such as
"./str" or "lib/foo") then make is told that the
generated files depend on the library. This
helps to ensure that changes to your libraries are
taken into account, which is important if you are
regenerating your libraries frequently.
* CLIBS - C-libraries that should be linked (just plain names).
* PRE_TARGETS - set this to a list of target files that you want
to have buildt before dependency calculation actually
takes place. E.g. use this to automatically compile
modules needed by camlp4, which have to be available
before other modules can be parsed at all.
** WARNING **: the files mentioned in this variable
will be removed when "make clean" is executed!
* LIBINSTALL_FILES - the files of a library that should be installed
using "findlib". Default:
$(RESULT).mli $(RESULT).cmi $(RESULT).cma
$(RESULT).cmxa $(RESULT).a lib$(RESULT).a
* OCAML_LIB_INSTALL - target directory for "rawinstall/rawuninstall".
(default: $(OCAMLLIBPATH)/contrib)
* DOC_FILES - names of files from which documentation is generated.
(default: all .mli-files in your $(SOURCES)).
* DOC_DIR - name of directory where documentation should be stored.
* OCAMLFLAGS - flags passed to the compilers
* OCAMLBCFLAGS - flags passed to the byte code compiler only
* OCAMLNCFLAGS - flags passed to the native code compiler only
* OCAMLLDFLAGS - flags passed to the OCaml-linker
* OCAMLBLDFLAGS - flags passed to the OCaml-linker when linking byte code
* OCAMLNLDFLAGS - flags passed to the OCaml-linker when linking
native code
* OCAMLMKLIB_FLAGS - flags passed to the OCaml library tool
* OCAMLCPFLAGS - profiling flags passed to "ocamlcp" (default: "a")
* PPFLAGS - additional flags passed to the preprocessor (default: none)
* LFLAGS - flags passed to "ocamllex"
* YFLAGS - flags passed to "ocamlyacc"
* IDLFLAGS - flags passed to "camlidl"
* OCAMLDOCFLAGS - flags passed to "ocamldoc"
* OCAMLFIND_INSTFLAGS - flags passed to "ocamlfind" during installation
(default: none)
* DVIPSFLAGS - flags passed to dvips
(when generating documentation in PostScript).
* STATIC - set this variable if you want to force creation
of static libraries
* CC - the C-compiler to be used
* CXX - the C++-compiler to be used
* CFLAGS - additional flags passed to the C-compiler.
The flag "-DNATIVE_CODE" will be passed automatically
if you choose to build native code. This allows you
to compile your C-files conditionally. But please
note: You should do a "make clean" or remove the
object files manually or touch the %.c-files:
otherwise, they may not be correctly recompiled
between different builds.
* CXXFLAGS - additional flags passed to the C++-compiler.
* CPPFLAGS - additional flags passed to the C-preprocessor.
* CFRAMEWORKS - Objective-C framework to pass to linker on MacOS X.
* LDFLAGS - additional flags passed to the C-linker
* RPATH_FLAG - flag passed through to the C-linker to set a path for
dynamic libraries. May need to be set by user on
exotic platforms. (default: "-R").
* ELF_RPATH_FLAG - this flag is used to set the rpath on ELF-platforms.
(default: "-R")
* ELF_RPATH - if this flag is "yes", then the RPATH_FLAG will be
passed by "-Wl" to the linker as normal on
ELF-platforms.
* OCAMLLIBPATH - path to the OCaml-standard-libraries
(first default: `$(OCAMLC) -where`)
(second default: "/usr/local/lib/ocaml")
* OCAML_DEFAULT_DIRS - additional path in which the user can supply
default directories to his own collection of
libraries. The idea is to pass this as an environment
variable so that the Makefiles do not have to contain
this path all the time.
* OCAMLFIND - ocamlfind from findlib (default: "ocamlfind")
* OCAMLC - byte-code compiler (default: "ocamlc")
* OCAMLOPT - native-code compiler (default: "ocamlopt")
* OCAMLMKTOP - top-level compiler (default: "ocamlmktop")
* OCAMLCP - profiling byte-code compiler (default: "ocamlcp")
* OCAMLDEP - dependency generator (default: "ocamldep")
* OCAMLLEX - scanner generator (default: "ocamllex")
* OCAMLYACC - parser generator (default: "ocamlyacc")
* OCAMLMKLIB - tool to create libraries (default: "ocamlmklib")
* CAMLIDL - IDL-code generator (default: "camlidl")
* CAMLIDLDLL - IDL-utility (default: "camlidldll")
* CAMLP4 - camlp4 preprocessor (default: "camlp4")
* OCAMLDOC - OCamldoc-command (default: "ocamldoc")
* LATEX - Latex-processor (default: "latex")
* DVIPS - dvips-command (default: "dvips")
* PS2PDF - PostScript-to-PDF converter (default: "ps2pdf")
* CAMELEON_REPORT - report tool of Cameleon (default: "report")
* CAMELEON_REPORT_FLAGS - flags for the report tool of Cameleon
* CAMELEON_ZOGGY - zoggy tool of Cameleon
(default: "camlp4o pa_zog.cma pr_o.cmo")
* CAMELEON_ZOGGY_FLAGS - flags for the zoggy tool of Cameleon
* OCAML_GLADECC - Glade compiler for OCaml (default: "lablgladecc2")
* OCAML_GLADECC_FLAGS - flags for the Glade compiler
* OXRIDL - OXRIDL-generator (default: "oxridl")
* NOIDLHEADER - set to "yes" to prohibit "OCamlMakefile" from using
the default camlidl-flag "-header".
* NO_CUSTOM - Prevent linking in custom mode.
* QUIET - unsetting this variable (e.g. "make QUIET=")
will print all executed commands, including
intermediate ones. This allows more comfortable
debugging when things go wrong during a build.
* REALLY_QUIET - when set this flag turns off output from some commands.
* OCAMLMAKEFILE - location of (=path to) this "OCamlMakefile".
Because it calles itself recursively, it has to
know where it is. (default: "OCamlMakefile" =
local directory)
* BCSUFFIX - Suffix for all byte-code files. E.g.:
RESULT = foo
BCSUFFIX = _bc
This will produce byte-code executables/libraries
with basename "foo_bc".
* NCSUFFIX - Similar to "BCSUFFIX", but for native-code files.
* TOPSUFFIX - Suffix added to toplevel interpreters (default: ".top")
* SUBPROJS - variable containing the names of subprojects to be
compiled.
* SUBTARGET - target to be built for all projects in variable
SUBPROJS.
---------------------------------------------------------------------------
Optional variables for Windows users
* MINGW - variable to detect the MINGW-environment
* MSVC - variable to detect the MSVC-compiler
---------------------------------------------------------------------------
Up-to-date information (newest release of distribution) can always be
found at:
http://www.ocaml.info/home/ocaml_sources.html
---------------------------------------------------------------------------
Enjoy!
New York, 2007-04-22
Markus Mottl
e-mail: markus.mottl@gmail.com
WWW: http://www.ocaml.info

119
vendor/git.apache.org/thrift.git/lib/ocaml/README.md generated vendored Normal file
View file

@ -0,0 +1,119 @@
Thrift OCaml Software Library
License
=======
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
Library
=======
The library abstract classes, exceptions, and general use functions
are mostly jammed in Thrift.ml (an exception being
TServer).
Generally, classes are used, however they are often put in their own
module along with other relevant types and functions. The classes
often called t, exceptions are called E.
Implementations live in their own files. There is TBinaryProtocol,
TSocket, TThreadedServer, TSimpleServer, and TServerSocket.
A note on making the library: Running make should create native, debug
code libraries, and a toplevel.
Struct format
-------------
Structs are turned into classes. The fields are all option types and
are initially None. Write is a method, but reading is done by a
separate function (since there is no such thing as a static
class). The class type is t and is in a module with the name of the
struct.
enum format
-----------
Enums are put in their own module along with
functions to_i and of_i which convert the ocaml types into ints. For
example:
enum Numberz
{
ONE = 1,
TWO,
THREE,
FIVE = 5,
SIX,
EIGHT = 8
}
==>
module Numberz =
struct
type t =
| ONE
| TWO
| THREE
| FIVE
| SIX
| EIGHT
let of_i = ...
let to_i = ...
end
typedef format
--------------
Typedef turns into the type declaration:
typedef i64 UserId
==>
type userid Int64.t
exception format
----------------
The same as structs except that the module also has an exception type
E of t that is raised/caught.
For example, with an exception Xception,
raise (Xception.E (new Xception.t))
and
try
...
with Xception.E e -> ...
list format
-----------
Lists are turned into OCaml native lists.
Map/Set formats
---------------
These are both turned into Hashtbl.t's. Set values are bool.
Services
--------
The client is a class "client" parametrized on input and output
protocols. The processor is a class parametrized on a handler. A
handler is a class inheriting the iface abstract class. Unlike other
implementations, client does not implement iface since iface functions
must take option arguments so as to deal with the case where a client
does not send all the arguments.

5
vendor/git.apache.org/thrift.git/lib/ocaml/TODO generated vendored Normal file
View file

@ -0,0 +1,5 @@
Write interfaces
Clean up the code generator
Avoid capture properly instead of relying on the user not to use _

19
vendor/git.apache.org/thrift.git/lib/ocaml/_oasis generated vendored Normal file
View file

@ -0,0 +1,19 @@
Name: libthrift-ocaml
Version: 0.10.0
OASISFormat: 0.3
Synopsis: OCaml bindings for the Apache Thrift RPC system
Authors: Apache Thrift Developers <dev@thrift.apache.org>
License: Apache-2.0
Homepage: http://thrift.apache.org
BuildTools: ocamlbuild
Plugins: META (0.3),
DevFiles (0.3)
Library "libthrift-ocaml"
Path: src
FindlibName: thrift
buildTools: ocamlbuild
BuildDepends: threads
Modules: Thrift,TBinaryProtocol,TSocket,TFramedTransport,TChannelTransport,TServer,TSimpleServer,TServerSocket,TThreadedServer
XMETARequires: threads

1
vendor/git.apache.org/thrift.git/lib/ocaml/coding_standards.md generated vendored Normal file
View file

@ -0,0 +1 @@
Please follow [General Coding Standards](/doc/coding_standards.md)

171
vendor/git.apache.org/thrift.git/lib/ocaml/src/TBinaryProtocol.ml generated vendored Normal file
View file

@ -0,0 +1,171 @@
(*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
*)
open Thrift
module P = Protocol
let get_byte i b = 255 land (i lsr (8*b))
let get_byte32 i b = 255 land (Int32.to_int (Int32.shift_right i (8*b)))
let get_byte64 i b = 255 land (Int64.to_int (Int64.shift_right i (8*b)))
let tv = P.t_type_to_i
let vt = P.t_type_of_i
let comp_int b n =
let s = ref 0l in
let sb = 32 - 8*n in
for i=0 to (n-1) do
s:= Int32.logor !s (Int32.shift_left (Int32.of_int (int_of_char b.[i])) (8*(n-1-i)))
done;
Int32.shift_right (Int32.shift_left !s sb) sb
let comp_int64 b n =
let s = ref 0L in
for i=0 to (n-1) do
s:=Int64.logor !s (Int64.shift_left (Int64.of_int (int_of_char b.[i])) (8*(n-1-i)))
done;
!s
let version_mask = 0xffff0000l
let version_1 = 0x80010000l
class t trans =
object (self)
inherit P.t trans
val ibyte = String.create 8
method writeBool b =
ibyte.[0] <- char_of_int (if b then 1 else 0);
trans#write ibyte 0 1
method writeByte i =
ibyte.[0] <- char_of_int (get_byte i 0);
trans#write ibyte 0 1
method writeI16 i =
let gb = get_byte i in
ibyte.[1] <- char_of_int (gb 0);
ibyte.[0] <- char_of_int (gb 1);
trans#write ibyte 0 2
method writeI32 i =
let gb = get_byte32 i in
for i=0 to 3 do
ibyte.[3-i] <- char_of_int (gb i)
done;
trans#write ibyte 0 4
method writeI64 i=
let gb = get_byte64 i in
for i=0 to 7 do
ibyte.[7-i] <- char_of_int (gb i)
done;
trans#write ibyte 0 8
method writeDouble d =
self#writeI64 (Int64.bits_of_float d)
method writeString s=
let n = String.length s in
self#writeI32 (Int32.of_int n);
trans#write s 0 n
method writeBinary a = self#writeString a
method writeMessageBegin (n,t,s) =
self#writeI32 (Int32.logor version_1 (Int32.of_int (P.message_type_to_i t)));
self#writeString n;
self#writeI32 (Int32.of_int s)
method writeMessageEnd = ()
method writeStructBegin s = ()
method writeStructEnd = ()
method writeFieldBegin (n,t,i) =
self#writeByte (tv t);
self#writeI16 i
method writeFieldEnd = ()
method writeFieldStop =
self#writeByte (tv (P.T_STOP))
method writeMapBegin (k,v,s) =
self#writeByte (tv k);
self#writeByte (tv v);
self#writeI32 (Int32.of_int s)
method writeMapEnd = ()
method writeListBegin (t,s) =
self#writeByte (tv t);
self#writeI32 (Int32.of_int s)
method writeListEnd = ()
method writeSetBegin (t,s) =
self#writeByte (tv t);
self#writeI32 (Int32.of_int s)
method writeSetEnd = ()
method readByte =
ignore (trans#readAll ibyte 0 1);
Int32.to_int (comp_int ibyte 1)
method readI16 =
ignore (trans#readAll ibyte 0 2);
Int32.to_int (comp_int ibyte 2)
method readI32 =
ignore (trans#readAll ibyte 0 4);
comp_int ibyte 4
method readI64 =
ignore (trans#readAll ibyte 0 8);
comp_int64 ibyte 8
method readDouble =
Int64.float_of_bits (self#readI64)
method readBool =
self#readByte = 1
method readString =
let sz = Int32.to_int (self#readI32) in
let buf = String.create sz in
ignore (trans#readAll buf 0 sz);
buf
method readBinary = self#readString
method readMessageBegin =
let ver = self#readI32 in
if Int32.compare (Int32.logand ver version_mask) version_1 != 0 then
raise (P.E (P.BAD_VERSION, "Missing version identifier"))
else
let s = self#readString in
let mt = P.message_type_of_i (Int32.to_int (Int32.logand ver 0xFFl)) in
(s,mt, Int32.to_int self#readI32)
method readMessageEnd = ()
method readStructBegin =
""
method readStructEnd = ()
method readFieldBegin =
let t = (vt (self#readByte))
in
if t != P.T_STOP then
("",t,self#readI16)
else ("",t,0);
method readFieldEnd = ()
method readMapBegin =
let kt = vt (self#readByte) in
let vt = vt (self#readByte) in
(kt,vt, Int32.to_int self#readI32)
method readMapEnd = ()
method readListBegin =
let t = vt (self#readByte) in
(t, Int32.to_int self#readI32)
method readListEnd = ()
method readSetBegin =
let t = vt (self#readByte) in
(t, Int32.to_int self#readI32);
method readSetEnd = ()
end
class factory =
object
inherit P.factory
method getProtocol tr = new t tr
end

39
vendor/git.apache.org/thrift.git/lib/ocaml/src/TChannelTransport.ml generated vendored Normal file
View file

@ -0,0 +1,39 @@
(*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
*)
open Thrift
module T = Transport
class t (i,o) =
object (self)
val mutable opened = true
inherit Transport.t
method isOpen = opened
method opn = ()
method close = close_in i; opened <- false
method read buf off len =
if opened then
try
really_input i buf off len; len
with _ -> raise (T.E (T.UNKNOWN, ("TChannelTransport: Could not read "^(string_of_int len))))
else
raise (T.E (T.NOT_OPEN, "TChannelTransport: Channel was closed"))
method write buf off len = output o buf off len
method flush = flush o
end

93
vendor/git.apache.org/thrift.git/lib/ocaml/src/TFramedTransport.ml generated vendored Normal file
View file

@ -0,0 +1,93 @@
open Thrift
module T = Transport
let c_0xff_32 = Int32.of_string "0xff"
(* Copied from OCamlnet rtypes.ml *)
let encode_frame_size x =
let s = String.create 4 in
let n3 = Int32.to_int (Int32.shift_right_logical x 24) land 0xff in
let n2 = Int32.to_int (Int32.shift_right_logical x 16) land 0xff in
let n1 = Int32.to_int (Int32.shift_right_logical x 8) land 0xff in
let n0 = Int32.to_int (Int32.logand x c_0xff_32) in
String.unsafe_set s 0 (Char.unsafe_chr n3);
String.unsafe_set s 1 (Char.unsafe_chr n2);
String.unsafe_set s 2 (Char.unsafe_chr n1);
String.unsafe_set s 3 (Char.unsafe_chr n0);
s
let decode_frame_size s =
let n3 = Int32.of_int (Char.code s.[0]) in
let n2 = Int32.of_int (Char.code s.[1]) in
let n1 = Int32.of_int (Char.code s.[2]) in
let n0 = Int32.of_int (Char.code s.[3]) in
Int32.logor
(Int32.shift_left n3 24)
(Int32.logor
(Int32.shift_left n2 16)
(Int32.logor
(Int32.shift_left n1 8)
n0))
class t ?(max_length=Sys.max_string_length) (transport: T.t) =
object (self)
inherit T.t
method isOpen = transport#isOpen
method opn = transport#opn
method close = transport#close
val mutable read_buf = None
val mutable read_buf_offset = 0
val mutable write_buf = ""
method private read_frame =
let len_buf = String.create 4 in
assert (transport#readAll len_buf 0 4 = 4);
let size = Int32.to_int (decode_frame_size len_buf) in
(if size < 0
then failwith (Printf.sprintf "Read a negative frame size (%i)!" size));
(if size > max_length
then failwith (Printf.sprintf "Frame size (%i) larger than max length (%i)!" size max_length));
let buf = String.create size in
assert (transport#readAll buf 0 size = size);
read_buf <- Some buf;
read_buf_offset <- 0
method private read_from_frame frame buf off len =
let to_copy = min len ((String.length frame) - read_buf_offset) in
String.blit frame read_buf_offset buf off to_copy;
read_buf_offset <- read_buf_offset + to_copy;
to_copy
method read buf off len =
match read_buf with
| Some frame ->
let i = self#read_from_frame frame buf off len in
if i > 0
then i
else begin
self#read_frame;
self#read_from_frame frame buf off len
end
| None ->
self#read_frame;
self#read buf off len
method write buf off len =
write_buf <- write_buf ^ (String.sub buf off len)
method flush =
let encoded_size = encode_frame_size (Int32.of_int (String.length write_buf)) in
transport#write encoded_size 0 (String.length encoded_size);
transport#write write_buf 0 (String.length write_buf);
transport#flush;
write_buf <- ""
end

42
vendor/git.apache.org/thrift.git/lib/ocaml/src/TServer.ml generated vendored Normal file
View file

@ -0,0 +1,42 @@
(*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
*)
open Thrift
class virtual t
(pf : Processor.t)
(st : Transport.server_t)
(tf : Transport.factory)
(ipf : Protocol.factory)
(opf : Protocol.factory)=
object
method virtual serve : unit
end;;
let run_basic_server proc port =
Unix.establish_server (fun inp -> fun out ->
let trans = new TChannelTransport.t (inp,out) in
let proto = new TBinaryProtocol.t (trans :> Transport.t) in
try
while proc#process proto proto do () done; ()
with e -> ()) (Unix.ADDR_INET (Unix.inet_addr_of_string "127.0.0.1",port))

41
vendor/git.apache.org/thrift.git/lib/ocaml/src/TServerSocket.ml generated vendored Normal file
View file

@ -0,0 +1,41 @@
(*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
*)
open Thrift
class t port =
object
inherit Transport.server_t
val mutable sock = None
method listen =
let s = Unix.socket Unix.PF_INET Unix.SOCK_STREAM 0 in
sock <- Some s;
Unix.bind s (Unix.ADDR_INET (Unix.inet_addr_any, port));
Unix.listen s 256
method close =
match sock with
Some s -> Unix.shutdown s Unix.SHUTDOWN_ALL; Unix.close s;
sock <- None
| _ -> ()
method acceptImpl =
match sock with
Some s -> let (fd,_) = Unix.accept s in
new TChannelTransport.t (Unix.in_channel_of_descr fd,Unix.out_channel_of_descr fd)
| _ -> raise (Transport.E (Transport.NOT_OPEN,"TServerSocket: Not listening but tried to accept"))
end

40
vendor/git.apache.org/thrift.git/lib/ocaml/src/TSimpleServer.ml generated vendored Normal file
View file

@ -0,0 +1,40 @@
(*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
*)
open Thrift
module S = TServer
class t pf st tf ipf opf =
object
inherit S.t pf st tf ipf opf
method serve =
try
st#listen;
while true do
let c = st#accept in
let trans = tf#getTransport c in
let inp = ipf#getProtocol trans in
let op = opf#getProtocol trans in
try
while (pf#process inp op) do () done;
trans#close
with e -> trans#close; raise e
done
with _ -> ()
end

59
vendor/git.apache.org/thrift.git/lib/ocaml/src/TSocket.ml generated vendored Normal file
View file

@ -0,0 +1,59 @@
(*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
*)
open Thrift
module T = Transport
class t host port=
object (self)
inherit T.t
val mutable chans = None
method isOpen = chans != None
method opn =
try
let addr = (let {Unix.h_addr_list=x} = Unix.gethostbyname host in x.(0)) in
chans <- Some(Unix.open_connection (Unix.ADDR_INET (addr,port)))
with
Unix.Unix_error (e,fn,_) -> raise (T.E (T.NOT_OPEN, ("TSocket: Could not connect to "^host^":"^(string_of_int port)^" because: "^fn^":"^(Unix.error_message e))))
| _ -> raise (T.E (T.NOT_OPEN, ("TSocket: Could not connect to "^host^":"^(string_of_int port))))
method close =
match chans with
None -> ()
| Some(inc,out) -> (Unix.shutdown_connection inc;
close_in inc;
chans <- None)
method read buf off len = match chans with
None -> raise (T.E (T.NOT_OPEN, "TSocket: Socket not open"))
| Some(i,o) ->
try
really_input i buf off len; len
with
Unix.Unix_error (e,fn,_) -> raise (T.E (T.UNKNOWN, ("TSocket: Could not read "^(string_of_int len)^" from "^host^":"^(string_of_int port)^" because: "^fn^":"^(Unix.error_message e))))
| _ -> raise (T.E (T.UNKNOWN, ("TSocket: Could not read "^(string_of_int len)^" from "^host^":"^(string_of_int port))))
method write buf off len = match chans with
None -> raise (T.E (T.NOT_OPEN, "TSocket: Socket not open"))
| Some(i,o) -> output o buf off len
method flush = match chans with
None -> raise (T.E (T.NOT_OPEN, "TSocket: Socket not open"))
| Some(i,o) -> flush o
end

45
vendor/git.apache.org/thrift.git/lib/ocaml/src/TThreadedServer.ml generated vendored Normal file
View file

@ -0,0 +1,45 @@
(*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
*)
open Thrift
class t
(pf : Processor.t)
(st : Transport.server_t)
(tf : Transport.factory)
(ipf : Protocol.factory)
(opf : Protocol.factory)=
object
inherit TServer.t pf st tf ipf opf
method serve =
st#listen;
while true do
let tr = tf#getTransport (st#accept) in
ignore (Thread.create
(fun _ ->
let ip = ipf#getProtocol tr in
let op = opf#getProtocol tr in
try
while pf#process ip op do
()
done
with _ -> ()) ())
done
end

383
vendor/git.apache.org/thrift.git/lib/ocaml/src/Thrift.ml generated vendored Normal file
View file

@ -0,0 +1,383 @@
(*
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
*)
exception Break;;
exception Thrift_error;;
exception Field_empty of string;;
class t_exn =
object
val mutable message = ""
method get_message = message
method set_message s = message <- s
end;;
module Transport =
struct
type exn_type =
| UNKNOWN
| NOT_OPEN
| ALREADY_OPEN
| TIMED_OUT
| END_OF_FILE;;
exception E of exn_type * string
class virtual t =
object (self)
method virtual isOpen : bool
method virtual opn : unit
method virtual close : unit
method virtual read : string -> int -> int -> int
method readAll buf off len =
let got = ref 0 in
let ret = ref 0 in
while !got < len do
ret := self#read buf (off+(!got)) (len - (!got));
if !ret <= 0 then
raise (E (UNKNOWN, "Cannot read. Remote side has closed."));
got := !got + !ret
done;
!got
method virtual write : string -> int -> int -> unit
method virtual flush : unit
end
class factory =
object
method getTransport (t : t) = t
end
class virtual server_t =
object (self)
method virtual listen : unit
method accept = self#acceptImpl
method virtual close : unit
method virtual acceptImpl : t
end
end;;
module Protocol =
struct
type t_type =
| T_STOP
| T_VOID
| T_BOOL
| T_BYTE
| T_I08
| T_I16
| T_I32
| T_U64
| T_I64
| T_DOUBLE
| T_STRING
| T_UTF7
| T_STRUCT
| T_MAP
| T_SET
| T_LIST
| T_UTF8
| T_UTF16
let t_type_to_i = function
T_STOP -> 0
| T_VOID -> 1
| T_BOOL -> 2
| T_BYTE -> 3
| T_I08 -> 3
| T_I16 -> 6
| T_I32 -> 8
| T_U64 -> 9
| T_I64 -> 10
| T_DOUBLE -> 4
| T_STRING -> 11
| T_UTF7 -> 11
| T_STRUCT -> 12
| T_MAP -> 13
| T_SET -> 14
| T_LIST -> 15
| T_UTF8 -> 16
| T_UTF16 -> 17
let t_type_of_i = function
0 -> T_STOP
| 1 -> T_VOID
| 2 -> T_BOOL
| 3 -> T_BYTE
| 6-> T_I16
| 8 -> T_I32
| 9 -> T_U64
| 10 -> T_I64
| 4 -> T_DOUBLE
| 11 -> T_STRING
| 12 -> T_STRUCT
| 13 -> T_MAP
| 14 -> T_SET
| 15 -> T_LIST
| 16 -> T_UTF8
| 17 -> T_UTF16
| _ -> raise Thrift_error
type message_type =
| CALL
| REPLY
| EXCEPTION
| ONEWAY
let message_type_to_i = function
| CALL -> 1
| REPLY -> 2
| EXCEPTION -> 3
| ONEWAY -> 4
let message_type_of_i = function
| 1 -> CALL
| 2 -> REPLY
| 3 -> EXCEPTION
| 4 -> ONEWAY
| _ -> raise Thrift_error
class virtual t (trans: Transport.t) =
object (self)
val mutable trans_ = trans
method getTransport = trans_
(* writing methods *)
method virtual writeMessageBegin : string * message_type * int -> unit
method virtual writeMessageEnd : unit
method virtual writeStructBegin : string -> unit
method virtual writeStructEnd : unit
method virtual writeFieldBegin : string * t_type * int -> unit
method virtual writeFieldEnd : unit
method virtual writeFieldStop : unit
method virtual writeMapBegin : t_type * t_type * int -> unit
method virtual writeMapEnd : unit
method virtual writeListBegin : t_type * int -> unit
method virtual writeListEnd : unit
method virtual writeSetBegin : t_type * int -> unit
method virtual writeSetEnd : unit
method virtual writeBool : bool -> unit
method virtual writeByte : int -> unit
method virtual writeI16 : int -> unit
method virtual writeI32 : Int32.t -> unit
method virtual writeI64 : Int64.t -> unit
method virtual writeDouble : float -> unit
method virtual writeString : string -> unit
method virtual writeBinary : string -> unit
(* reading methods *)
method virtual readMessageBegin : string * message_type * int
method virtual readMessageEnd : unit
method virtual readStructBegin : string
method virtual readStructEnd : unit
method virtual readFieldBegin : string * t_type * int
method virtual readFieldEnd : unit
method virtual readMapBegin : t_type * t_type * int
method virtual readMapEnd : unit
method virtual readListBegin : t_type * int
method virtual readListEnd : unit
method virtual readSetBegin : t_type * int
method virtual readSetEnd : unit
method virtual readBool : bool
method virtual readByte : int
method virtual readI16 : int
method virtual readI32: Int32.t
method virtual readI64 : Int64.t
method virtual readDouble : float
method virtual readString : string
method virtual readBinary : string
(* skippage *)
method skip typ =
match typ with
| T_STOP -> ()
| T_VOID -> ()
| T_BOOL -> ignore self#readBool
| T_BYTE
| T_I08 -> ignore self#readByte
| T_I16 -> ignore self#readI16
| T_I32 -> ignore self#readI32
| T_U64
| T_I64 -> ignore self#readI64
| T_DOUBLE -> ignore self#readDouble
| T_STRING -> ignore self#readString
| T_UTF7 -> ()
| T_STRUCT -> ignore ((ignore self#readStructBegin);
(try
while true do
let (_,t,_) = self#readFieldBegin in
if t = T_STOP then
raise Break
else
(self#skip t;
self#readFieldEnd)
done
with Break -> ());
self#readStructEnd)
| T_MAP -> ignore (let (k,v,s) = self#readMapBegin in
for i=0 to s do
self#skip k;
self#skip v;
done;
self#readMapEnd)
| T_SET -> ignore (let (t,s) = self#readSetBegin in
for i=0 to s do
self#skip t
done;
self#readSetEnd)
| T_LIST -> ignore (let (t,s) = self#readListBegin in
for i=0 to s do
self#skip t
done;
self#readListEnd)
| T_UTF8 -> ()
| T_UTF16 -> ()
end
class virtual factory =
object
method virtual getProtocol : Transport.t -> t
end
type exn_type =
| UNKNOWN
| INVALID_DATA
| NEGATIVE_SIZE
| SIZE_LIMIT
| BAD_VERSION
| NOT_IMPLEMENTED
| DEPTH_LIMIT
exception E of exn_type * string;;
end;;
module Processor =
struct
class virtual t =
object
method virtual process : Protocol.t -> Protocol.t -> bool
end;;
class factory (processor : t) =
object
val processor_ = processor
method getProcessor (trans : Transport.t) = processor_
end;;
end
(* Ugly *)
module Application_Exn =
struct
type typ=
| UNKNOWN
| UNKNOWN_METHOD
| INVALID_MESSAGE_TYPE
| WRONG_METHOD_NAME
| BAD_SEQUENCE_ID
| MISSING_RESULT
| INTERNAL_ERROR
| PROTOCOL_ERROR
| INVALID_TRANSFORM
| INVALID_PROTOCOL
| UNSUPPORTED_CLIENT_TYPE
let typ_of_i = function
0l -> UNKNOWN
| 1l -> UNKNOWN_METHOD
| 2l -> INVALID_MESSAGE_TYPE
| 3l -> WRONG_METHOD_NAME
| 4l -> BAD_SEQUENCE_ID
| 5l -> MISSING_RESULT
| 6l -> INTERNAL_ERROR
| 7l -> PROTOCOL_ERROR
| 8l -> INVALID_TRANSFORM
| 9l -> INVALID_PROTOCOL
| 10l -> UNSUPPORTED_CLIENT_TYPE
| _ -> raise Thrift_error;;
let typ_to_i = function
| UNKNOWN -> 0l
| UNKNOWN_METHOD -> 1l
| INVALID_MESSAGE_TYPE -> 2l
| WRONG_METHOD_NAME -> 3l
| BAD_SEQUENCE_ID -> 4l
| MISSING_RESULT -> 5l
| INTERNAL_ERROR -> 6l
| PROTOCOL_ERROR -> 7l
| INVALID_TRANSFORM -> 8l
| INVALID_PROTOCOL -> 9l
| UNSUPPORTED_CLIENT_TYPE -> 10l
class t =
object (self)
inherit t_exn
val mutable typ = UNKNOWN
method get_type = typ
method set_type t = typ <- t
method write (oprot : Protocol.t) =
oprot#writeStructBegin "TApplicationExeception";
if self#get_message != "" then
(oprot#writeFieldBegin ("message",Protocol.T_STRING, 1);
oprot#writeString self#get_message;
oprot#writeFieldEnd)
else ();
oprot#writeFieldBegin ("type",Protocol.T_I32,2);
oprot#writeI32 (typ_to_i typ);
oprot#writeFieldEnd;
oprot#writeFieldStop;
oprot#writeStructEnd
end;;
let create typ msg =
let e = new t in
e#set_type typ;
e#set_message msg;
e
let read (iprot : Protocol.t) =
let msg = ref "" in
let typ = ref 0l in
ignore iprot#readStructBegin;
(try
while true do
let (name,ft,id) =iprot#readFieldBegin in
if ft = Protocol.T_STOP
then raise Break
else ();
(match id with
| 1 -> (if ft = Protocol.T_STRING
then msg := (iprot#readString)
else iprot#skip ft)
| 2 -> (if ft = Protocol.T_I32
then typ := iprot#readI32
else iprot#skip ft)
| _ -> iprot#skip ft);
iprot#readFieldEnd
done
with Break -> ());
iprot#readStructEnd;
let e = new t in
e#set_type (typ_of_i !typ);
e#set_message !msg;
e;;
exception E of t
end;;