ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-11-20 19:15:54 +00:00
Code Issues Packages Projects Releases Wiki Activity

Beast initial commit

Browse Source
This commit is contained in:
Vinnie Falco
2013-05-31 17:27:46 -07:00
parent 70df832967
commit b96e3111b2
11 changed files with 443 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Subtrees/README.txt Normal file
View File

@@ -0,0 +1,2 @@
These directories come from entire outside repositories
brought in using git-subtree.

12
Subtrees/beast/.gitattributes vendored Normal file
View File

@@ -0,0 +1,12 @@
# Set default behaviour, in case users don't have core.autocrlf set.
* text=auto
# Github
.md text eol=lf
# Visual Studio
*.sln text eol=crlf
*.vcproj text eol=crlf
*.vcxproj text eol=crlf
*.props text eol=crlf
*.filters text eol=crlf

3
Subtrees/beast/.gitignore vendored Normal file
View File

@@ -0,0 +1,3 @@
Builds/VisualStudio2012/Debug
Builds/VisualStudio2012/Release
Builds/VisualStudio2012/*.user

88
Subtrees/beast/Builds/VisualStudio2012/beast.vcxproj Normal file
View File

@@ -0,0 +1,88 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<None Include="..\..\CodingStyle.md" />
<None Include="..\..\modules\beast_core.mm" />
<None Include="..\..\README.md" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\modules\beast_core.h" />
<ClInclude Include="..\..\modules\memory\beast_ScopedPointer.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\modules\beast_core.cpp" />
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{73C5A0F0-7629-4DE7-9194-BE7AC6C19535}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>beast</RootNamespace>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v110</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v110</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup />
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<PrecompiledHeader>
</PrecompiledHeader>
<WarningLevel>Level3</WarningLevel>
<Optimization>Disabled</Optimization>
<PreprocessorDefinitions>WIN32;_DEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<PrecompiledHeader>
</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>WIN32;NDEBUG;_LIB;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
</Link>
</ItemDefinitionGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

31
Subtrees/beast/Builds/VisualStudio2012/beast.vcxproj.filters Normal file
View File

@@ -0,0 +1,31 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<None Include="..\..\README.md" />
<None Include="..\..\CodingStyle.md" />
<None Include="..\..\modules\beast_core.mm">
<Filter>beast_core</Filter>
</None>
</ItemGroup>
<ItemGroup>
<Filter Include="beast_core">
<UniqueIdentifier>{6dafd8d5-2901-4b41-85b7-52f6e86baacc}</UniqueIdentifier>
</Filter>
<Filter Include="beast_core\memory">
<UniqueIdentifier>{883f776d-bec2-4e7a-b4e8-726ed3039071}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\modules\memory\beast_ScopedPointer.h">
<Filter>beast_core\memory</Filter>
</ClInclude>
<ClInclude Include="..\..\modules\beast_core.h">
<Filter>beast_core</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\modules\beast_core.cpp">
<Filter>beast_core</Filter>
</ClCompile>
</ItemGroup>
</Project>

200
Subtrees/beast/CodingStyle.md Normal file
View File

@@ -0,0 +1,200 @@
--------------------------------------------------------------------------------
# Coding Standards
Coding standards used here are extreme strict and consistent. The style
evolved gradually over the years, incorporating generally acknowledged
best-practice C++ advice, experience, and personal preference.
## D.R.Y.: Don't Repeat Yourself!
The [Don't Repeat Yourself][1] principle summarises the essence of what it
means to write good code, in all languages, at all levels.
## Formatting
* No tab characters!
* Tabs are 4 spaces!
* Braces are indented in the [Allman style][2].
* Always put a space before and after all binary operators, especially
the assignment `operator=`!
* The `!` operator should always be followed by a space.
* The `~` operator should be preceded by a space, but not followed by one.
* The `++` and `--` operators should have no spaces between the operator and its
operand.
* Never put a space before a comma. Always put a space after a comma.
* Always put a space before an open parenthesis! (One exception to this is if
you've got a pair of empty parentheses)
* Don't put spaces after a parenthesis. A typical member function call might
look like this: `foobar (1, 2, 3);`
* In general, leave a blank line before an `if` statement.
* In general, leave a blank line after a closing brace `}`.
* Do not write `if` statements all-on-one-line. The exception to this is when
you've got a sequence of similar if statements, and are aligning them all
vertically to highlight their similarities.
* In an `if-else` statement, if you surround one half of the statement with
braces, you also need to put braces around the other half, to match.
* When writing a pointer type, use this spacing: `SomeObject* myObject`.
Technically, a more correct spacing would be `SomeObject *myObject`, but
it makes more sense for the asterisk to be grouped with the type name,
since being a pointer is part of the type, not the variable name. The only
time that this can lead to any problems is when you're declaring multiple
pointers of the same type in the same statement - which leads on to the next
rule:
* When declaring multiple pointers, never do so in a single statement, e.g.
`SomeObject* p1, *p2;` - instead, always split them out onto separate lines
and write the type name again, to make it quite clear what's going on, and
avoid the danger of missing out any vital asterisks.
* The previous point also applies to references, so always put the `&` next to
the type rather than the variable, e.g. "void foo (const Thing& thing)". And
don't put a space on both sides of the `*` or `&` - always put a space after
it, but never before it.
* The word `const` should be placed to the right of the thing that it modifies,
for consistency. For example `int const` refers to an int which is const.
`int const*` is a pointer to an int which is const. `int *const` is a const
pointer to an int.
* Always place a space in between the template angle brackets and the type
name. Template code is already hard enough to read!
## Naming conventions
* Member variables and method names are written with camel-case, and never begin
with a capital letter.
* Class names are also written in camel-case, but always begin with a capital
letter.
* For global variables... well, you shouldn't have any, so it doesn't matter.
* Class data members begin with `m_`, static data members begin with `s_`. Global
variables begin with `g_`. This is so the scope of the corresponding declaration
can be easily determined.
* Avoid underscores in your names, especially leading or trailing underscores.
In particular, leading underscores should be avoided, as these are often used
in standard library code, so to use them in your own code looks quite jarring.
* If you really have to write a macro for some reason, then make it all caps,
with underscores to separate the words. And obviously make sure that its name
is unlikely to clash with symbols used in other libraries or 3rd party code.
## Types, const-correctness, etc
* If a method can (and should!) be const, make it const!
* If a method definitely doesn't throw an exception (be careful!), mark it as
`noexcept`
* When returning a temporary object, e.g. a String, the returned object should be
non-const, so that if the class has a C++11 move operator, it can be used.
* If a local variable can be const, then make it const!
* Remember that pointers can be const as well as primitives - for example, if you
have a char pointer whose contents are going to be altered, you may still be
able to make the pointer itself const, e.g. `char* const foobar = getFoobar();`.
* Do not declare all your local variables at the top of a function or method
(i.e. in the old-fashioned C-style). Declare them at the last possible moment,
and give them as small a scope as possible.
* Object parameters should be passed as const references wherever possible. Only
pass a parameter as a copy-by-value object if you really need to mutate a local
copy inside the method, and if making a local copy inside the method would be
difficult.
* Use portable `for()` loop variable scoping (i.e. do not have multiple for loops
in the same scope that each re-declare the same variable name, as this fails on
older compilers)
* When you're testing a pointer to see if it's null, never write `if (myPointer)`.
Always avoid that implicit cast-to-bool by writing it more fully:
`if (myPointer != nullptr)`. And likewise, never ever write `if (! myPointer)`,
instead always write `if (myPointer == null)`. It is more readable that way.
* Avoid C-style casts except when converting between primitive numeric types.
Some people would say "avoid C-style casts altogether", but `static_cast` is
a bit unreadable when you just want to cast an `int` to a `float`. But whenever
a pointer is involved, or a non-primitive object, always use `static_cast`.
And when you're reinterpreting data, always use `reinterpret_cast`.
* Until C++ gets a universal 64-bit primitive type (part of the C++11 standard),
it's best to stick to the int64 and uint64 typedefs.
## Object lifetime and ownership
* Absolutely do NOT use `delete`, `deleteAndZero`, etc. There are very very few
situations where you can't use a `ScopedPointer` or some other automatic
lifetime management class.
* Do not use `new` unless there's no alternative. Whenever you type `new`, always
treat it as a failure to find a better solution. If a local variable can be
allocated on the stack rather than the heap, then always do so.
* Do not ever use `new` or `malloc` to allocate a C++ array. Always use a
`HeapBlock` instead.
* ..and just to make it doubly clear: Never use `malloc` or `calloc`.
* If a parent object needs to create and own some kind of child object, always
use composition as your first choice. If that's not possible (e.g. if the child
needs a pointer to the parent for its constructor), then use a `ScopedPointer`.
* If possible, pass an object as a reference rather than a pointer. If possible,
make it a const reference.
* Obviously avoid static and global values. Sometimes there's no alternative, but
if there is an alternative, then use it, no matter how much effort it involves.
* If allocating a local POD structure (e.g. an operating-system structure in
native code), and you need to initialise it with zeros, use the `= { 0 };`
syntax as your first choice for doing this. If for some reason that's not
appropriate, use the `zerostruct()` function, or in case that isn't suitable,
use `zeromem()`. Don't use `memset()`.
## Classes
* Declare a class's public section first, and put its constructors and destructor
first. Any protected items come next, and then private ones.
* Preferred
positioning for any inherited classes is to put them to the right of the class
name, vertically aligned, e.g.:
class Thing : public Foo,
private Bar
{
}
* Put a class's member variables (which should almost always be private, of course),
after all the public and protected method declarations.
* Any private methods can go towards the end of the class, after the member
variables.
* If your class does not have copy-by-value semantics, derive the class from
`Uncopyable`.
* If your class is likely to be leaked, then derive your class from
`LeakChecked<>`.
* Constructors that take a single parameter should be default be marked
`explicit`. Obviously there are cases where you do want implicit conversion,
but always think about it carefully before writing a non-explicit constructor.
* Do not use `NULL`, `null`, or 0 for a null-pointer. And especially never use
'0L', which is particulary burdensome. Use `nullptr` instead - this is the
C++2011 standard, so get used to it. There's a fallback definition for `nullptr`
in Beast, so it's always possible to use it even if your compiler isn't yet
C++2011 compliant.
* All the C++ 'guru' books and articles are full of excellent and detailed advice
on when it's best to use inheritance vs composition. If you're not already
familiar with the received wisdom in these matters, then do some reading!
## Miscellaneous
* Don't use macros! OK, obviously there are many situations where they're the
right tool for the job, but treat them as a last resort. Certainly don't ever
use a macro just to hold a constant value or to perform any kind of function
that could have been done as a real inline function. And it goes without saying
that you should give them names which aren't going to clash with other code.
And #undef them after you've used them, if possible.
* When using the ++ or -- operators, never use post-increment if pre-increment
could be used instead. Although it doesn't matter for primitive types, it's good
practice to pre-increment since this can be much more efficient for more complex
objects. In particular, if you're writing a for loop, always use pre-increment,
e.g. `for (int = 0; i < 10; ++i)`
* Never put an "else" statement after a "return"! This is well-explained in the
LLVM coding standards...and a couple of other very good pieces of advice from
the LLVM standards are in there as well.
* When getting a possibly-null pointer and using it only if it's non-null, limit
the scope of the pointer as much as possible - e.g. Do NOT do this:
Foo* f = getFoo(); if (f != nullptr) f->doSomething();
...lots of code...
f->doSomething(); // oops! f may be null!
..instead, prefer to write it like this, which reduces the scope of the
pointer, making it impossible to write code that accidentally uses a null
pointer:
if (Foo* f = getFoo())
f->doSomethingElse();
// f is out-of-scope here, so impossible to use it if it's null
(This also results in smaller, cleaner code)
[1]: http://en.wikipedia.org/wiki/Don%27t_repeat_yourself
[2]: http://en.wikipedia.org/wiki/Indent_style#Allman_style

8
Subtrees/beast/ReadMe.md Normal file
View File

@@ -0,0 +1,8 @@
# Beast: An amazing cross platform library
Contains cross platform objects to do a variety of useful things.
No external dependencies, no complicated build steps.
Things people need for building peer to peer, concurrent, cryptographic systems.
The hope is that this will replace the use of boost and other cumbersome jalopies.

2
Subtrees/beast/modules/beast_core/beast_core.cpp Normal file
View File

@@ -0,0 +1,2 @@
#include "beast_core.h"

10
Subtrees/beast/modules/beast_core/beast_core.h Normal file
View File

@@ -0,0 +1,10 @@
#include <algorithm>
#include <cstdlib>
namespace beast
{
#include "memory/beast_ScopedPointer.h"
}

1
Subtrees/beast/modules/beast_core/beast_core.mm Normal file
View File

@@ -0,0 +1 @@
#include "beast_core.cpp"

86
Subtrees/beast/modules/beast_core/memory/beast_ScopedPointer.h Normal file
View File

@@ -0,0 +1,86 @@
#ifndef BEAST_SCOPEDPOINTER_BEASTHEADER
#define BEAST_SCOPEDPOINTER_BEASTHEADER
template <class ObjectType>
class ScopedPointer
{
public:
inline ScopedPointer() : object (0)
{
}
inline ScopedPointer (ObjectType* const objectToTakePossessionOf)
: object (objectToTakePossessionOf)
{
}
ScopedPointer (ScopedPointer& objectToTransferFrom)
: object (objectToTransferFrom.object)
{
objectToTransferFrom.object = 0;
}
inline ~ScopedPointer() { delete object; }
ScopedPointer& operator= (ScopedPointer& objectToTransferFrom)
{
if (this != objectToTransferFrom.getAddress())
{
ObjectType* const oldObject = object;
object = objectToTransferFrom.object;
objectToTransferFrom.object = 0;
delete oldObject;
}
return *this;
}
ScopedPointer& operator= (ObjectType* const newObjectToTakePossessionOf)
{
if (object != newObjectToTakePossessionOf)
{
ObjectType* const oldObject = object;
object = newObjectToTakePossessionOf;
delete oldObject;
}
return *this;
}
inline operator ObjectType*() const { return object; }
inline ObjectType* get() const { return object; }
inline ObjectType& operator*() const { return *object; }
inline ObjectType* operator->() const { return object; }
ObjectType* release() { ObjectType* const o = object; object = 0; return o; }
void swapWith (ScopedPointer <ObjectType>& other)
{
std::swap (object, other.object);
}
private:
ObjectType* object;
const ScopedPointer* getAddress() const { return this; }
#ifndef _MSC_VER
ScopedPointer (const ScopedPointer&);
ScopedPointer& operator= (const ScopedPointer&);
#endif
};
template <class ObjectType>
bool operator== (const ScopedPointer<ObjectType>& pointer1, ObjectType* const pointer2)
{
return static_cast <ObjectType*> (pointer1) == pointer2;
}
template <class ObjectType>
bool operator!= (const ScopedPointer<ObjectType>& pointer1, ObjectType* const pointer2)
{
return static_cast <ObjectType*> (pointer1) != pointer2;
}
#endif