If you're new to Mesos
See the getting started page for more information about downloading, building, and deploying Mesos.
If you'd like to get involved or you're looking for support
See our community page for more details.
Mesos C++ Style Guide
The Mesos codebase follows the Google C++ Style Guide with some notable differences, as described below. Note that the clang-format tool can be helpful to ensure that some of the mechanical style rules are obeyed.
Scoping
Namespaces
- We avoid
using namespace foo
statements as it is not explicit about which symbols are pulled in, and it can often pull in a lot of symbols, which sometimes lead to conflicts. - It is OK to use namespace aliases to help pull in sub-namespaces, such as
namespace http = process::http;
. These should only be present at the top of the .cpp file.
Naming
Variable Names
- We use lowerCamelCase for variable names in Mesos application code (Google uses snake_case, and their class member variables have trailing underscores).
- We use snake_case for variable names in the libprocess and stout libraries.
- We prepend constructor and function arguments with a leading underscore to avoid ambiguity and / or shadowing:
Try(State _state, T* _t = nullptr, const std::string& _message = "")
: state(_state), t(_t), message(_message) {}
Prefer trailing underscores for use as member fields (but not required). Some trailing underscores are used to distinguish between similar variables in the same scope (think prime symbols), but this should be avoided as much as possible, including removing existing instances in the code base.
If you find yourself creating a copy of an argument passed by const reference, consider passing it by value instead (if you don’t want to use a leading underscore and copy in the body of the function):
// You can pass-by-value in ProtobufProcess::install() handlers.
void Slave::statusUpdate(StatusUpdate update, const UPID& pid)
{
...
update.mutable_status()->set_source(
pid == UPID() ? TaskStatus::SOURCE_SLAVE : TaskStatus::SOURCE_EXECUTOR);
...
}
Constant Names
- We use SCREAMING_SNAKE_CASE for constant names in Mesos, libprocess, and stout (Google uses a
k
followed by mixed case, e.g.kDaysInAWeek
).
Function Names
- We use lowerCamelCase for function names in Mesos application code (Google uses mixed case for regular functions; and their accessors and mutators match the name of the variable).
- We use snake_case for function names in the libprocess and stout libraries.
Class Names
- We use UpperCamelCase for class and struct names in Mesos, libprocess, and stout.
Strings
- Strings used in log and error messages should end without a period.
- ID values in log and error messages should be enclosed in single quotes only if they might contain a space; this includes all IDs not generated by Mesos.
Comments
- End each sentence within a comment with a punctuation mark (please note that we generally prefer periods); this applies to incomplete sentences as well.
- For trailing comments, leave one space.
- Use backticks when quoting code excerpts or object/variable/function names. For example:
// Use `SchedulerDriver::acceptOffers()` to send several offer
// operations. This makes use of the `RESERVE()` and `UNRESERVE()`
// helpers, which take a `Resources` object as input and produce
// appropriate offer operations. Note that we are unreserving the
// resources contained in `dynamicallyReserved1`.
driver.acceptOffers({offer.id()},
{UNRESERVE(dynamicallyReserved1),
RESERVE(dynamicallyReserved2),
RESERVE(dynamicallyReserved3)},
filters);
Breaks
- Break before braces on enum, function, and record (i.e. struct, class, union) definitions.
Indentation
Class Format
- Access modifiers are not indented (Google uses one space indentation).
- Constructor initializers are indented by two spaces (Google indents by four).
Templates
- Leave one space after the
template
keyword, e.g.template <typename T>
rather thantemplate<typename T>
.
Function Definition/Invocation
- Newline when calling or defining a function: indent with four spaces.
- We do not follow Google’s style of wrapping on the open parenthesis, the general goal is to reduce visual “jaggedness” in the code. Prefer (1), (4), (5), sometimes (3), never (2):
// 1: OK.
allocator->resourcesRecovered(frameworkId, agentId, resources, filters);
// 2: Don't use.
allocator->resourcesRecovered(frameworkId, agentId,
resources, filters);
// 3: Don't use in this case due to "jaggedness".
allocator->resourcesRecovered(frameworkId,
agentId,
resources,
filters);
// 3: In this case, 3 is OK.
foobar(someArgument,
someOtherArgument,
theLastArgument);
// 4: OK.
allocator->resourcesRecovered(
frameworkId,
agentId,
resources,
filters);
// 5: OK.
allocator->resourcesRecovered(
frameworkId, agentId, resources, filters);
Continuation
- Newline for an assignment statement: indent with two spaces.
Try<Duration> failoverTimeout =
Duration::create(FrameworkInfo().failover_timeout());
Empty Lines
- One empty line at the end of the file.
- Inside a code block, every multi-line statement should be followed by one empty line.
Try<very_very_long_type> long_name =
::protobuf::parse<very_very_long_type>(
request);
for (int i = 0; i < very_very_long_expression();
i++) {
// No empty line here for control constructs.
}
- Elements outside classes (classes, structs, global functions, etc.) should be spaced apart by two empty lines.
- Elements inside classes (member variables and functions) should not be spaced apart by more than one empty line.
Capture by Reference
We disallow capturing temporaries by reference. See MESOS-2629 for the rationale.
Future<Nothing> f() { return Nothing(); }
Future<bool> g() { return false; }
struct T
{
T(const char* data) : data(data) {}
const T& member() const { return *this; }
const char* data;
};
// 1: Don't use.
const Future<Nothing>& future = f();
// 1: Instead use.
const Future<Nothing> future = f();
// 2: Don't use.
const Future<Nothing>& future = Future<Nothing>(Nothing());
// 2: Instead use.
const Future<Nothing> future = Future<Nothing>(Nothing());
// 3: Don't use.
const Future<bool>& future = f().then(lambda::bind(g));
// 3: Instead use.
const Future<bool> future = f().then(lambda::bind(g));
// 4: Don't use (since the T that got constructed is a temporary!).
const T& t = T("Hello").member();
// 4: Preferred alias pattern (see below).
const T t("Hello");
const T& t_ = t.member();
// 4: Can also use.
const T t = T("Hello").member();
We allow capturing non-temporaries by constant reference when the intent is to alias.
The goal is to make code more concise and improve readability. Use this if an expression referencing a field by const
is:
- Used repeatedly.
- Would benefit from a concise name to provide context for readability.
- Will not be invalidated during the lifetime of the alias. Otherwise document this explicitly.
hashmap<string, hashset<int>> index;
// 1: Ok.
const hashset<int>& values = index[2];
// 2: Ok.
for (auto iterator = index.begin(); iterator != index.end(); ++iterator) {
const hashset<int>& values = iterator->second;
}
// 3: Ok.
foreachpair (const string& key, const hashset<int>& values, index) {}
foreachvalue (const hashset<int>& values, index) {}
foreachkey (const string& key, index) {}
// 4: Avoid aliases in most circumstances as they can be dangerous.
// This is an example of a dangling alias!
vector<string> strings{"hello"};
string& s = strings[0];
strings.erase(strings.begin());
s += "world"; // THIS IS A DANGLING REFERENCE!
File Headers
Mesos source files must contain the “ASF” header:
// 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.
Stout and libprocess source files must contain the “Apache License Version 2.0” header:
// Licensed 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
Order of includes
In addition to the ordering rules from the Google style guide, Mesos related headers are separated into sections. Newline to separate each section.
Mesos related headers in include
directories are partitioned by their subfolders, sorted alphabetically, and included using brackets.
Header in src
directories are included afterwards, using the same rules but with quotes instead of brackets.
Example for src/common/foo.cpp
:
#include "common/foo.hpp"
#include <stdint.h>
#include <string>
#include <vector>
#include <boost/circular_buffer.hpp>
#include <mesos/mesos.hpp>
#include <mesos/type_utils.hpp>
#include <mesos/module/authenticator.hpp>
#include <mesos/scheduler/scheduler.hpp>
#include <process/http.hpp>
#include <process/protobuf.hpp>
#include <stout/foreach.hpp>
#include <stout/hashmap.hpp>
#include "common/build.hpp"
#include "common/protobuf_utils.hpp"
#include "master/flags.hpp"
C++11
We support C++11 and require GCC 4.8+ or Clang 3.5+ compilers. The whitelist of supported C++11 features is:
nullptr
- Static assertions.
- Multiple right angle brackets.
- Type inference (
auto
anddecltype
). The main goal is to increase code readability. This is safely the case if the exact same type omitted on the left is already fully stated on the right. Here are several examples:
// 1: OK.
const auto i = values.find(keys.front());
// Compare with
const typename map::iterator i = values.find(keys.front());
// 2: OK.
auto names = shared_ptr<list<string>>(new list<string>());
// Compare with
shared_ptr<list<string>> names = shared_ptr<list<string>>(new list<string>());
// 3: Don't use.
auto authorizer = LocalAuthorizer::create(acls);
// Compare with
Try<Owned<LocalAuthorizer>> authorizer = LocalAuthorizer::create();
- Rvalue references.
- Explicitly-defaulted functions.
- Variadic templates.
- Delegating constructors.
- Mutexes.
std::mutex
std::lock_guard<std::mutex>
std::unique_lock<std::mutex>
- Atomics (
std::atomic
)- The standard defines a number of predefined typedefs for atomic types (e.g.,
std::atomic_int
), in addition tostd::atomic<T>
. When a typedef is available, it should be preferred over explicit template specialization ofstd::atomic<T>
. - When reading from and writing to atomic values, the
load
andstore
member functions should be used instead of the overloads ofoperator T()
andoperator=
. Being explicit helps to draw the reader’s attention to the fact that atomic values are being manipulated.
- The standard defines a number of predefined typedefs for atomic types (e.g.,
- Shared from this.
class T : public std::enable_shared_from_this<T>
shared_from_this()
- Lambdas!
- Don’t put a space between the capture list and the parameter list:
// 1: OK.
[]() { ...; };
// 2: Don't use.
[] () { ...; };
- Prefer default capture by value, explicit capture by value, then capture by reference. To avoid dangling-pointer bugs, never use default capture by reference:
// 1: OK.
[=]() { ... }; // Default capture by value.
[n]() { ... }; // Explicit capture by value.
[&n]() { ... }; // Explicit capture by reference.
[=, &n]() { ... }; // Default capture by value, explicit capture by reference.
// 2: Don't use.
[&]() { ... }; // Default capture by reference.
- Use
mutable
only when absolutely necessary.
// 1: OK.
[]() mutable { ...; };
- Feel free to ignore the return type by default, adding it as necessary to appease the compiler or be more explicit for the reader.
// 1: OK.
[]() { return true; };
[]() -> bool { return ambiguous(); };
- Feel free to use
auto
when naming a lambda expression:
// 1: OK.
auto lambda = []() { ...; };
- Format lambdas similar to how we format functions and methods. Feel free to let lambdas be one-liners:
// 1: OK.
auto lambda = []() {
...;
};
// 2: OK.
auto lambda = []() { ...; };
- Feel free to inline lambdas within function arguments:
instance.method([]() {
...;
});
- Chain function calls on a newline after the closing brace of the lambda and the closing parenthesis of function call:
// 1: OK.
instance
.method([]() {
...;
})
.then([]() { ...; })
.then([]() {
...;
});
// 2: OK (when no chaining, compare to 1).
instance.method([]() {
...;
});
// 3: OK (if no 'instance.method').
function([]() {
...;
})
.then([]() { ...; })
.then([]() {
...;
});
// 3: OK (but prefer 1).
instance.method([]() {
...;
})
.then([]() { ...; })
.then([]() {
...;
});
- Wrap capture lists independently of parameters, use the same formatting as if the capture list were template parameters:
// 1: OK.
function([&capture1, &capture2, &capture3](
const T1& p1, const T2& p2, const T3& p3) {
...;
});
function(
[&capture1, &capture2, &capture3](
const T1& p1, const T2& p2, const T3& p3) {
...;
});
auto lambda = [&capture1, &capture2, &capture3](
const T1& p1, const T2& p2, const T3& p3) {
...;
};
auto lambda =
[&capture1, &capture2, &capture3](
const T1& p1, const T2& p2, const T3& p3) {
...;
};
// 2: OK (when capture list is longer than 80 characters).
function([
&capture1,
&capture2,
&capture3,
&capture4](
const T1& p1, const T2& p2) {
...;
});
auto lambda = [
&capture1,
&capture2,
&capture3,
&capture4](
const T1& p1, const T2& p2) {
...;
};
// 3: OK (but prefer 2).
function([
&capture1,
&capture2,
&capture3,
&capture4](const T1& p1, const T2& t2) {
...;
});
auto lambda = [
&capture1,
&capture2,
&capture3,
&capture4](const T1& p1, const T2& p2) {
...;
};
// 3: Don't use.
function([&capture1,
&capture2,
&capture3,
&capture4](const T1& p1, const T2& p2) {
...;
});
auto lambda = [&capture1,
&capture2,
&capture3,
&capture4](const T1& p1, const T2& p2) {
...;
};
// 4: Don't use.
function([&capture1,
&capture2,
&capture3,
&capture4](
const T1& p1, const T2& p2, const T3& p3) {
...;
});
auto lambda = [&capture1,
&capture2,
&capture3,
&capture4](
const T1& p1, const T2& p2, const T3& p3) {
...;
};
// 5: Don't use.
function([&capture1,
&capture2,
&capture3,
&capture4](
const T1& p1,
const T2& p2,
const T3& p3) {
...;
});
auto lambda = [&capture1,
&capture2,
&capture3,
&capture4](
const T1& p1,
const T2& p2,
const T3& p3) {
...;
};
// 6: OK (parameter list longer than 80 characters).
function([&capture1, &capture2, &capture3](
const T1& p1,
const T2& p2,
const T3& p3,
const T4& p4) {
...;
});
auto lambda = [&capture1, &capture2, &capture3](
const T1& p1,
const T2& p2,
const T3& p3,
const T4& p4) {
...;
};
// 7: OK (capture and parameter lists longer than 80 characters).
function([
&capture1,
&capture2,
&capture3,
&capture4](
const T1& p1,
const T2& p2,
const T3& p3,
const T4& p4) {
...;
});
auto lambda = [
&capture1,
&capture2,
&capture3,
&capture4](
const T1& p1,
const T2& p2,
const T3& p3,
const T4& p4) {
...;
};
Unrestricted Union.
Like the pre-existing
union
, we can overlap storage allocation for objects that never exist simultaneously. However, with C++11 we are no longer restricted to having only non-POD types in unions. Adding non-POD types to unions complicates things, however, because we need to make sure to properly call constructors and destructors. Therefore, only use unrestricted unions (i.e., unions with non-POD types) when the union has only a single field. What does this buy us? Now we can avoid dynamic memory allocations for “container” like types, e.g.,Option
,Try
,Result
, etc. In effect, we treat the union like a dynamic allocation, calling placement new,new (&t) T(...)
anyplace we would have just callednew T(...)
and the destructort.~T()
anyplace we would have calleddelete t
.Constant expressions.
Constant expressions allow the declaration of static non-POD objects while eliminating the unpredictable runtime initialization and destruction issues normally encountered, helping eliminate macros and hard-coded literals without sacrificing performance and type safety. Changes which require converting from
constexpr
toconst
can propagate through the dependency tree requiring that dependentconstexpr
uses also be converted toconst
, hence we avoid usingconstexpr
in complex functions.constexpr
behaves as a combination ofinline
andconst
and hence must be defined before use in anotherconstexpr
.Prefer
constexpr
toconst
for all constant POD declarations,constexpr
char
arrays are preferred toconst
string
literals.
// OK
constexpr char LITERAL[] = "value";
// Not OK - not available at compile time for optimization and
// definition required in a separate compilation module.
const char LITERAL[];
// Not OK - uncertain initialization order, cannot be used in other
// constexpr statements.
const string LITERAL("value");
constexpr
functions are evaluated at compile time if all their arguments are constant expressions. Otherwise they default to initialization at runtime. However constexpr
functions are limited in that they cannot perform dynamic casts, memory allocation or calls to non-constexpr functions. Prefer constexpr
over const inline functions.
constexpr size_t MIN = 200;
constexpr size_t MAX = 1000;
constexpr size_t SPAN() { return MAX-MIN; }
int array[SPAN()];
Const expression constructors allow object initialization at compile time provided that all the constructor arguments are constexpr
and the constructor body is empty, i.e. all initialization is performed in the initialization list. Classes which provide constexpr
constructors should normally also provide constexpr
copy constructors to allow the class to be used in the return value from a constexpr
function.
class C
{
public:
constexpr C(int _i) : i(_i) {};
constexpr C(const C& c) : i(c.i) {}
private:
const int i;
};
C++11 does not provide constexpr string
or constexpr
containers in the STL and hence constexpr
cannot be used for any class using stout’s Error() class.


vbox is a BoxLayout container with vertical placement of components.
vbox
BoxLayout
spacing attribute sets spacing between components within a container.
spacing


Eval of Julia code¶
One of the hardest parts about learning how the Julia Language runs code is learning how all of the pieces work together to execute a block of code.
Each chunk of code typically makes a trip through many esoteric acronyms such as (in no particular order),
flisp
, AST
, C++
, LLVM
, eval
, typeinf
, macroexpand
, sysimg
(or system image
), bootstrapping
,
compile
, parse
, execute
, JIT
, interpret
, box
, unbox
, intrinsic function
, primitive function
before turning into the desired result (hopefully).
Julia Execution¶
The 10,000 foot view of the whole process is as follows:
- The user starts
julia
. - The C function
main()
fromui/repl.c
gets called. This function processes the command line arguments, filling in thejl_options
struct and setting the variableARGS
. It then initializes Julia (by calling julia_init in task.c, which may load a previously compiled sysimg). Finally, it passes off control to Julia by calling Base._start(). - When
_start()
takes over control, the subsequent sequence of commands depends on the command line arguments given. For example, if a filename was supplied, it will proceed to execute that file. Otherwise, it will start an interactive REPL. - Skipping the details about how the REPL interacts with the user, let’s just say the program ends up with a block of code that it wants to run.
- If the block of code to run is in a file, jl_load(char *filename)
gets invoked to load the file and parse it. Each fragment of code is then passed to
eval
to execute. - Each fragment of code (or AST), is handed off to
eval()
to turn into results. eval()
takes each code fragment and tries to run it in jl_toplevel_eval_flex().jl_toplevel_eval_flex()
decides whether the code is a “toplevel” action (such asusing
ormodule
), which would be invalid inside a function. If so, it passes off the code to the toplevel interpreter.jl_toplevel_eval_flex()
then expands the code to eliminate any macros and to “lower” the AST to make it simpler to execute.jl_toplevel_eval_flex()
then uses some simple heuristics to decide whether to JIT compiler the AST or to interpret it directly.- The bulk of the work to interpret code is handled by eval in interpreter.c.
- If instead, the code is compiled, the bulk of the work is handled by
codegen.cpp
. Whenever a Julia function is called for the first time with a given set of argument types, type inference will be run on that function. This information is used by the codegen step to generate faster code. - Eventually, the user quits the REPL, or the end of the program is reached, and the
_start()
method returns. - Just before exiting,
main()
calls jl_atexit_hook(exit_code). This callsBase._atexit()
(which calls any functions registered toatexit()
inside Julia). Then it calls jl_gc_run_all_finalizers(). Finally, it gracefully cleans up alllibuv
handles and waits for them to flush and close.
Parsing¶
The Julia parser is a small lisp program written in femtolisp, the source-code for which is distributed inside Julia in src/flisp.
The interface functions for this are primarily defined in jlfrontend.scm. The code in ast.c handles this handoff on the Julia side.
The other relevant files at this stage are julia-parser.scm, which handles tokenizing Julia code and turning it into an AST, and julia-syntax.scm, which handles transforming complex AST representations into simpler, “lowered” AST representations which are more suitable for analysis and execution.
Macro Expansion¶
When eval()
encounters a macro, it expands that AST node before attempting to evaluate the expression.
Macro expansion involves a handoff from eval()
(in Julia), to the parser function jl_macroexpand()
(written in flisp
)
to the Julia macro itself (written in - what else - Julia) via fl_invoke_julia_macro()
, and back.
Typically, macro expansion is invoked as a first step during a call to expand()
/jl_expand()
,
although it can also be invoked directly by a call to macroexpand()
/jl_macroexpand()
.
Type Inference¶
Type inference is implemented in Julia by typeinf() in inference.jl. Type inference is the process of examining a Julia function and determining bounds for the types of each of its variables, as well as bounds on the type of the return value from the function. This enables many future optimizations, such as unboxing of known immutable values, and compile-time hoisting of various run-time operations such as computing field offsets and function pointers. Type inference may also include other steps such as constant propagation and inlining.
JIT Code Generation¶
Codegen is the process of turning a Julia AST into native machine code.
The JIT environment is initialized by an early call to jl_init_codegen in codegen.cpp.
On demand, a Julia method is converted into a native function by the function emit_function(jl_lambda_info_t*)
.
(note, when using the MCJIT (in LLVM v3.4+), each function must be JIT into a new module.)
This function recursively calls emit_expr()
until the entire function has been emitted.
Much of the remaining bulk of this file is devoted to various manual optimizations of specific code patterns.
For example, emit_known_call()
knows how to inline many of the primitive functions
(defined in builtins.c) for various combinations of argument types.
Other parts of codegen are handled by various helper files:
- debuginfo.cpp
- Handles backtraces for JIT functions
- ccall.cpp
- Handles the ccall and llvmcall FFI, along with various
abi_*.cpp
files - intrinsics.cpp
- Handles the emission of various low-level intrinsic functions
System Image¶
The system image is a precompiled archive of a set of Julia files.
The sys.ji
file distributed with Julia is one such system image,
generated by executing the file sysimg.jl,
and serializing the resulting environment (including Types, Functions, Modules, and all other defined values)
into a file. Therefore, it contains a frozen version of the Main
, Core
, and Base
modules (and whatever else was in the environment at the end of bootstrapping).
This serializer/deserializer is implemented by jl_save_system_image/jl_restore_system_image in dump.c.
If there is no sysimg file (jl_options.image_file == NULL
),
this also implies that --build
was given on the command line,
so the final result should be a new sysimg file.
During Julia initialization, minimal Core
and Main
modules are created.
Then a file named boot.jl
is evaluated from the current directory.
Julia then evaluates any file given as a command line argument until it reaches the end.
Finally, it saves the resulting environment to a “sysimg” file for use as a starting point for a future Julia run.


High level api¶
Face detection and attributes estimation¶
High level api is represented VLFaceDetection and VLFaceDetector classes.
VLFaceDetection is container for a face detection. It has properties which are corresponding face estimations. Every property is a singleton which estimates corresponding attribute once and remembers it for next calling.
VLFaceDetector is a wraper on FaceDetector which convert FaceDetection to VLFaceDetection. Class contains a face estimator collection as a class attribute for a detections attributes estimation. If you want specify an unique VLFaceEngine for the instance of VLFaceDetector you should set the FaceEngine in the init of the class.

- Returns
emotions
- Return type
float
Convert to dict.
- Returns
All estimated attributes will be added to dict
- Return type
Dict
[str
,Union
[dict
,list
,float
]]
Get all basic attributes of the detection.
- Returns
basic attributes (age, gender, ethnicity)
- Return type
Get a face descriptor from warp
- Returns
mouth state
- Return type
Get emotions of the detection.
- Returns
emotions
- Return type
Get eyes estimation of the detection.
- Returns
eyes estimation
- Return type
Get gaze direction.
- Returns
gaze direction
- Return type
Get a head pose of the detection.
- Returns
warp
- Return type
Get quality of warped image which corresponding the detection :returns: quality
- Return type
High level face detector. Return VLFaceDetection instead simple FaceDetection.
face estimator collections for new detections.
face detector
- Type
face engine for detector and estimators, default FACE_ENGINE.
- Type
Batch detect faces on images.
- Parameters
images – input images list. Format must be R8G8B8
limit – max number of detections per input image
- Returns
return list of lists detection, order of detection lists is corresponding to order input images
- Return type
List
[List
[VLFaceDetection
]]
Detect just one best detection on the image.
- Parameters
image – image. Format must be R8G8B8 (todo check)
detectArea – rectangle area which contains face to detect. If not set will be set image.rect
- Returns
face detection if face is found otherwise None
- Return type
Union
[None
,VLFaceDetection
]
estimators collection of class for usual creating detectors
-
faceEngine
= <lunavl.sdk.faceengine.engine.VLFaceEngine object> a global instance of FaceEngine for usual creating detectors
High level sample object.
lazy load emotions estimations
- Type
Optional[Emotions]
lazy load mouth state estimation
- Type
Optional[MouthStates]
lazy load basic attribute estimation
- Type
Optional[BasicAttributes]
lazy load warp quality estimation
- Type
Optional[Quality]
Convert to dict.
- Returns
All estimated attributes will be added to dict
- Return type
Dict
[str
,Union
[dict
,list
,float
]]
Get all basic attributes of the detection.
- Returns
basic attributes (age, gender, ethnicity)
- Return type
Get a face descriptor from warp
- Returns
mouth state
- Return type
Get emotions of the detection.
- Returns
emotions
- Return type
estimators collection of class for usual creating detectors
Get a mouth state of the detection
- Returns
mouth state
- Return type
Support VLFaceDetection interface.
- Returns
self
- Return type
Get quality of warped image which corresponding the detection :returns: quality
- Return type


Passed: {{ numPassed .Results }} / {{ numResults .Results }} ({{ printf "%.2f" (percent (numPassed .Results) (numResults .Results)) }}%)
| Query | Outcome |
|---|---|
|
{{ if .Success }}PASS{{ else }}FAIL{{ end }} |
| The query failed to run against the test target: {{ .UnexpectedFailure }} | |
| The query ran successfully against the test target, but should have failed. | |
|


h1 {
color: blue;
color: green;
color: red;
color: purple;
}
body {
background-color: blue;
background-color: green;
background-color: red;
background-color: purple;
}
p {
font-family: "Arvo";
font-family: "Cinzel";
font-family: "Lora";
font-family: "Hind";
font-size:"10px";
font-size:"15px";
font-size:"20px";
font-size:"25px";
text-align:right;
text-align:left;
text-align:center;
}
This Is A Header (size 1)
This Is A Header (size 2)
This Is A Header (size 3)
This is a paragraph.
This text is bold.
This text is italic.
This text is superscript.
This text is subscript.
This is an unordered list.
You can list items.
This list uses bullet points.
1. To start refer to the setup to learn how to save the file correctly
2. In order for you to link your HTML page to your CSS page, you will need to go to your HTML page and write
'<link href="helloStyle.css" rel="stylesheet">'
3. First lets change the background color! Your headings, text, pictures, etc. are in your body tag. So,
to change the background color for everything you need to do something like this:
(The 'Hello World' statement is just a place holder for us your website should say whatever you put in your HTML file)
You don't need to make the color cyan. CSS has only a couple of the basic colors that you can use by writing
their name, but you could replace the name with color codes that are in quotes. Here's a link to a bunch of different
color codes you could use.Click Here!
4. To change the fonts you have a couple of different options.
 Here's a link to some.
Click Here!
5. To change your font size you have the same two options. I will show you the way to do it separately
for your paragraphs and headers. You can also write the same line just in the body if you prefer to do it that way.
6. You have now changed your font, background color, and font size! The next step is changing your font color!
Once again like the features above you can do it all in the body if you want it all the same color.
Otherwise, you can choose to do it like we did it below:
Remember that you can get the hex color codes from the website linked above for background colors.
7. You've been probably wondering how to get your text aligned to the center, right, or left. Like all the ones above,
feel free to do it in the body if you want all your text to be aligned the same way.
your picture will already be aligned with the rest of your text. On the other hand if you separated it like
the example we showed this is how you will center your picture! Centering a picture is a bit more
complicated. This is because you will need to make a class and adjust parts in your HTML file and CSS file.
Below is your HTML file on top with a circle on additional things you need to add,
Css file in the middle, then the output on the bottom.
9. Your buttons may look very plain right now. Here's how to make them look sleek and exciting!
Of course there is always many ways to make your buttons look cool. For example, you can make them change
color when you hover or you could make them round or square! For our purposes we will teach you how to make them
rounded and how to change their color. Once again the pictures go from HTML, CSS, Output.
In this example there are a lot of the things that we talked about above put together.
You can change any of these things and you should play around with them to see what kind of
display you like.
Have fun exploring CSS!


HAPPINESS Cast: Jane Adams, Dylan Baker, Lara Flynn Boyle, Philip Seymour Hoffman, Cynthia Stevenson, Jared Harris, Ben Gazzara, Louise Lasser, Camryn Manheim Director: Todd Solondz Screenplay: Todd Solondz Reviewed by Luke Buckmaster
On the Buckmaster scale of 0 stars (bomb), to 5 stars (a masterpiece): 4 and a half stars
Over the last decade films have stumbled over themselves in their attempts to be "politically incorrect," and many have lost sight of the reality that they intended to display. Happiness, by independent filmmaker Todd Solondz, never falls into that trap. The film grounds itself in the bleak and unforgiving modern world of its dozen or so principal characters, and Solondz never relents from making his cold surroundings feel that much colder.
Yes, the title is intentionally ironic, and yes, the film is very sad. One scene, in which a character bitterly masturbates whilst ringing random numbers in a phone book, speaks volumes about the isolation of society as it approaches the new millenium. Controversial, off-putting and uncomfortable are three words that can describe Happiness, but there's much more to it than that. I propose that Happiness is not just a brilliantly constructed social commentary piece, but one of the most sarcastic, unapologetic and indirectly insightful black comedies ever made.
The film regularly cuts to each of its characters lives, all of them with distinguishable and quite unlikable personalities. Perhaps most tragic is that of Bill Maplewood (Dylan Baker), a married man who is also a pedophile, and is attracted to his eleven-year-old son Billy's (Rufus Read) friends. Trish (Cynthia Stevenson), Bill's wife, is a sister of Joy (Jane Adams), an aspiring songwriter who struggles to maintain a happy spirit through emotional tribulations. Successful author Helen (Lara Flynn Boyle), also a sister of Trish and Joy, receives obsessive phone conversations from neighbor Allen (Philip Seymour Hoffman), who longs for her whilst being oblivious to similar feelings towards him from Kristina (Cynthia Stevenson) a few doors down. That's without mentioning Joy's boyfriend (Jon Lovitz), who doesn't react well after being dumped, and the sisters' father (Ben Gazzara), who abandons his wife in search for contentment in life. Each of them pursue their desire to be happy, in expense of everybody else, but delve deeper into a world of uncertainty and despair.
Make no mistake about it; this is a painfully sad story. Interestingly enough, the film's dramatic side arrives second place in terms of focus and ingenuity to its incredible sarcasm and wit. The result is a dialogue driven film that is both unnerving and at times very funny, in a sadistic, glass-is-half-empty kind of way. It's a neat trick that Solondz uses to great effect, leaving viewers simultaneously shocked and amused, scathed and entertained.
Exceptional performances are contributed from all cast members, who dissect their characters with appropriately somber mannerisms, displaying the sadness of a world corrupted by greed and populated by people whose foremost desires are to pursue happiness. During all of Solondz's ranting and raving - his biting views on relationships, his misanthropic philosophies on the togetherness of society, and even his graphic shots of seamen - the film remains coherently structured, and maintains audience interest for all of its running time. Don't underestimate the importance of Happiness. See it, if not just to say that you've witnessed the bleakest film this side of a Shakespearean tragedy, and laughed guiltily whilst the actors in front of you sobbed miserably.
Read more of my reviews at In Film Australia http://infilmau.iah.net
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Although I have an adult-like appearance, I have a childlike heart and a dislike for the things that are too much alike. [G|D]
Although I have never seen a godlike figure or been part of a ladylike society, I often find myself dreaminglike and imagining what it would be like. [G|D]
From a distance, the manlike figure seems lifelike and similar to my own image, but upon closer inspection I can see the subtle differences from my own lookalike. [G|D]
Although the world has become increasingly unlike its traditional self, I still strive to be warlike in my perseverance and workmanlike in my attitude toward getting things done. [G|D]


{% extends "website/subneddit_base.html" %} {% load bootstrap4 %} {% block subneddit_content %}
{{ post.content|linebreaks }}
Nobody has commented yet :(


Function used to copy the current item into new item
function uvm_object
create
( string
name = "")
function void
create_new_detail_immediat_assertion
( string
immediate_assertion,
time
test_time,
svaunit_status_type
status)
Create new details for the immediate assertion : set name, the test time and the status for the current attempt of the immediate assertion
Arguments: immediate_assertion : the name of immediate assertion which is tested test_time : the time at which the immediate assertion was tested status : the current status of the immediate assertion
function string
get_immediate_assertion_detail
()
Get details for a immediate assertion
Returns: a string with all immediate assertion details
function string
get_immediate_assertion_name
()
Get immediate assertion name
Returns: the immediate assertion name
function int unsigned
get_nof_times_immediate_assertion_pass
()
Compute the number of times the immediate assertion passed during simulation
Returns: the number of times the immediate assertion passed during simulation
function int unsigned
get_nof_times_immediate_assertion_tested
()
Compute the number of times the immediate assertion was tested during simulation
Returns: the number of times the immediate assertion was tested during simulation
virtual function uvm_object_wrapper
get_object_type
()


FAQs
did crystal make this?
no, who do you think she is? please bug matt about this instead
where's the code?
source code at this repo
what font is this?
westwood sans, ACM's in-house font. it's still a work in progress
haven't i seen this site before?
see above
did you really buy a domain for this?
yes


This tool allows you to create custom reports. Any of the data provided can be sorted, filtered, joined, and displayed any way you see fit. The data is stored in tables. Once you add tables to your report, you need to select which fields should be displayed and how the data should be used. The diagram at the bottom is used for informational purposes to show you how tables are related and which fields are in each table. The form at the top of the page is where you create your report. Here are some basic instructions for using this tool.
Click the tables that you want to use in the box on the right of the page labeled “Tables”. These are the tables that will be included in your report. Clicking them will add or remove them to the “Table” dropdown.
You can click "Add Another Field" to add fields you want to display, join, filter, or sort on. After you click "Add Another Field", select a table you want to use in the Table dropdown and a Field for that Table in the Fields dropdown. It does not matter what order these are added to the form. Click the show checkbox to display the field in the results. You can filter or sort on a field without displaying it.
If all of the fields you want to select are on the same table, you don't need to join anything. But if you want data from two different tables, the tables must be joined together. Meaning, you must select how tables should be related to each other. After you select a table in the Table dropdown, the related tables are shown in the Fields dropdown in blue. Clicking the blue field will join the tables together as well as automatically adding the new table to the form. For example, if you select a Device table, you would select the Store field to join the Stores table. Now you can select things like the Device's IP address the Store's store number.
There are many filters to choose from. These are selected in the Criteria column. Some filters are only applicable to certain data types. Any filter with ( I ) prefixed indicates the filter is case insensitive. Greater than and less than filters can be used on numbers and dates. Example: If you filter dates that are less than a certain date, that will return dates that came before that date.
To sort you simply select ascending or descending in the Sort dropdown. If you sort on multiple fields, the sort will cascade if two items are equal, sorting on the next field in the form with a “Sort” option selected.
There are many example templates on the "Report Templates" button that should help give you an idea of how to use this tool.


Toggle navigation
Home
Profile
Messages
Dropdown
Home
Profile
Messages
LOG IN
×
Log IN
MALE
FEMALE
BCA
MCA
BTech
MTech
BSc
0-6
6-12
1
2
3
contact us
call us
Delhi : +91<PHONE_NUMBER> | Bhubaneswar : +91<PHONE_NUMBER>
Write to Us
Email<EMAIL_ADDRESS>Top


Class Log
Built in logger for Catapult SDK
will be used on exceptions, folders generated
relative to working directory.
NOTE if you are using ./logs for something else
you can reset the directory using
Catapult\Log::directory('new_directory');
To set off/on the logger
Catapult\Log::on(TRUE);
example output:
/logs/catapult_log_12-12-2014-2:05.log
Methods summary
public static
|
|
public static
|
#
find( )
can we find a member
for this log.
match by Y-M-D
can we find a member
for this log.
match by Y-M-D
|
public static
|
#
open( )
open the current
log. Set by day.
If we cannot open a folder,
file set catapult logging off
open the current
log. Set by day.
If we cannot open a folder,
file set catapult logging off
by default this will output in the current
directory. If there is a logs directory in the
folder, it will use that
|
public static
|
#
write( time: $time = '', object: $object = 'CALL', file: $message = '' )
Write to the log
accept a date, object and format
Write to the log
accept a date, object and format
Format: {file} - {app_id} [{time}] "{object}" {message}
Parameters
- $time
- timestamp
- $object
- Model Object
- $message
|
public static
|
|
public static
|
#
on( on: $on = TRUE )
turn on/off logging
Parameters
|
Properties summary
public static
boolean
|
$on
|
|
public static
|
$log_file
|
|
public static
|
$logger_opts
General purpose options
for logger
General purpose options
for logger
|
#
array(
"path" => __DEFAULT_LOG_USER_PATH__,
"mode" => "a"
)
|


---
title: Accepting URLs ending with a slash
---
# by Tomaz Lavieri, applied to VRaptor 4
For those who had some trouble to determine urls like:
~~~
#!java
@Path("product/{product.id}")
~~~
when typing a URI **/product/1/** and the link didn't work, here's a simple way to fixes the problem.
## Editor's Note
This is not necessarily a problem ... the URL /abc is different of /abc/, so the behavior to give 404 is expected. But if you want them to be equivalent URLs you can write the class below.
~~~
#!java
import javax.enterprise.context.RequestScoped;
import javax.enterprise.inject.Specializes;
import javax.inject.Inject;
import br.com.caelum.vraptor.Result;
import br.com.caelum.vraptor.controller.DefaultControllerNotFoundHandler;
import br.com.caelum.vraptor.controller.HttpMethod;
import br.com.caelum.vraptor.core.RequestInfo;
import br.com.caelum.vraptor.http.route.ControllerNotFoundException;
import br.com.caelum.vraptor.http.route.Router;
import br.com.caelum.vraptor.view.Results;
@RequestScoped
@Specializes
public class Error404 extends DefaultControllerNotFoundHandler {
private final Router router;
private final Result result;
@Inject
public Error404(Router router, Result result) {
this.router = router;
this.result = result;
}
/**
* @deprecated CDI eyes only
*/
public Error404() {
this(null, null);
}
@Override
public void couldntFind(RequestInfo requestInfo) {
try {
String uri = requestInfo.getRequestedUri();
if (uri.endsWith("/")) {
tryMovePermanentlyTo(requestInfo, uri.substring(0, uri.length()-1));
} else {
tryMovePermanentlyTo(requestInfo, uri + "/");
}
} catch (ControllerNotFoundException ex) {
super.couldntFind(requestInfo);
}
}
private void tryMovePermanentlyTo(RequestInfo requestInfo, String newUri) {
router.parse(newUri, HttpMethod.of(requestInfo.getRequest()),
requestInfo.getRequest());
result.use(Results.status()).movedPermanentlyTo(newUri);
}
}
~~~


Hello,
Anonymous
You have,
unknown
ETH balance.
Here
Username
Email address
We'll never share your email with anyone else.
Contact
Submit
Title
Description
Link
Deadline
Start Price
Submit
Bid
WEI
Submit
Auction List
Number
Seller
Title
Description
Link
Deadline (Block)
Start Price
Bids
Higest Bid
Bid List
Bidder
Amount
Value


Ok..I am wanting to build a fighter/blackguard..(if Blackguards are really worth doing).Want to end up fighter 30/Blackguard 10 or some variation thereof,no other classes.Any help with feats and such will be appreciated.
Oh yeah...has to use a Halberd _________________ Would you offer your throat to the wolf with a Rose in it's mouth?
Edited By Marcus Whitewolf on 10/08/07 22:33
IKD is handy for your Sneak Attacks. Of course EWS is great for Fighters as well. Is there a reason you only want two classes?
Edited By whirlin_merlin on 10/08/07 22:59
Well, that's too much Fighter IMO, you'll have too many feats and nothing good to place them on, I'd suggest something like a Fighter 18 / Blackguard 22, to increase your Sneak Attack at least.
You know, the basics...
Blind-Fight, Power Attack, Knockdown, Improved Critical, Weapon Focus, Epic Weapon Focus, Epic Prowess, Armor Skin, Weapon Spcialization, Epic Weapon Specialization, if you want dev crits then take Cleave, Great Cleave, Overwhelming Critical, Devastating Critical (if not then more feats to play with), Great Strength VI, whatever else you can, I'm not really counting how many I wrote, but it's 7 pre-epic and 7 epic if I remember correctly, plus 10 bonus feats from Fighter and 4 bonus feats from Blackguard. _________________ "My name is Thaxll'ssyllia, but you simians may refer to me merely as "Sir", if you prefer a less... syllable intensive workout."
Edwin Odesseiron - Baldur's Gate II: Shadows of Amn
I agree with Thax. That is too much Fighter. I dont think 10 BG levels would be worth much. I like to throw in some Rogue levels with that combo, but if you only want the two classes then I would go as heavy BG as possible. 12 Fighter/28 Blackguard.
Another option is to use Blackguard for Dark Blessing. That works best in a build that already has invested in Charisma for some reason; eg Sorcerer, smiter Paladin, Bard, and some builds with Cleric or CoT. _________________ I generally avoid temptation, unless I can't resist it...


Jeffrey Kenney Publications
Home
Research
Publications
Contact
A full list of publications is avaliable from the following sources:
arXiv
NASA ADS


gvfs-rename [OPTION...] {LOCATION} {NEW-NAME}
gvfs-rename renames a file.
gvfs-rename is similar to the traditional rename utility, but using gvfs locations instead of local files: for example you can use something like smb://server/resource/file.txt as location.
The following options are understood:
-h, --help
Prints a short help text and exits.
--version
Shows the version number and exits.
On success 0 is returned, a non-zero failure code otherwise.
rename(1), gvfs-move(1)


Home
Login
Cart
Checkout Details
Royal Apples
Rs. 175 per kg
Payment Details
To be paid : 175
Taxes : 5.9
Delivery : 30
Total : 250.9
Select Items
+
-
Buy Now


#include <Discord.h>
|
| | Discord (const string &token, const Intents &intents, const unsigned int num_shards=0) |
| |
| | Discord (const string &token, const Intents &intents, const unsigned int shard_id, const unsigned int num_shards) |
| |
| virtual | ~Discord () |
| |
| virtual void | on_ready (User user) |
| | called when successfully logged in More...
|
| |
| virtual void | on_message (Message message) |
| | called when a Message was received More...
|
| |
| virtual void | on_user_ban (User user, Guild guild) |
| | called when a Member was banned More...
|
| |
| virtual void | on_user_unban (User user, Guild guild) |
| | called when a Member was unbanned More...
|
| |
| virtual void | on_user_join (Member member, Guild guild) |
| | called when a User joins a Guild More...
|
| |
| virtual void | on_user_remove (User user, Guild guild) |
| | called when a User is removed from a Guild (leave/kick/ban) More...
|
| |
| virtual void | on_typing_start (User user, TextChannel channel, unsigned int timestamp) |
| | called when a User starts typing More...
|
| |
| pplx::task< void > | update_presence (const string &status, Activity activity=Activity(), const bool afk=false, const int shard_id=-1) |
| | updates the presence of user More...
|
| |
| | DiscordObject () |
| |
| | DiscordObject (const utility::string_t &token) |
| |
|
| MainGateway * | get_shard (const unsigned int shard_id) |
| |
| Guild * | get_guild (const string &guild_id) |
| |
| pplx::task< void > | connect () |
| |
| void | on_websocket_incoming_message (const value &payload) |
| |
| pplx::task< void > | handle_raw_event (const std::string &event_name, const value &data) |
| |
| web::json::value | api_call (const std::string &url, const web::http::method &method=web::http::methods::GET, const web::json::value &data=web::json::value(), const std::string &content_type="", const bool cache=true) |
| | helper function to communicate with the http api More...
|
| |
◆ Discord() [1/2]
| DiscordCPP::Discord::Discord |
( |
const string & |
token, |
|
|
const Intents & |
intents, |
|
|
const unsigned int |
num_shards = 0 |
|
) |
| |
Creates a Discord instance with one or more shards
- Parameters
-
| [in] | token | Bot token for authentication |
| [in] | intents | Intents used for the gateway. |
| [in] | num_shards | (optional) number of shards that exist (default: 0 used for automatic sharding) |
◆ Discord() [2/2]
| DiscordCPP::Discord::Discord |
( |
const string & |
token, |
|
|
const Intents & |
intents, |
|
|
const unsigned int |
shard_id, |
|
|
const unsigned int |
num_shards |
|
) |
| |
Creates a Discord instance with ONE shard
- Parameters
-
| [in] | token | Bot token for authentication |
| [in] | intents | Intents used for the gateway. |
| [in] | shard_id | (optional) the id of the shard (default: 0) |
| [in] | num_shards | (optional) number of shards that exist (default: 1) |
◆ ~Discord()
| DiscordCPP::Discord::~Discord |
( |
| ) |
|
|
virtual |
◆ connect()
| pplx::task< void > DiscordCPP::Discord::connect |
( |
| ) |
|
|
protected |
◆ get_guild()
◆ get_shard()
◆ handle_raw_event()
| pplx::task< void > DiscordCPP::Discord::handle_raw_event |
( |
const std::string & |
event_name, |
|
|
const value & |
data |
|
) |
| |
|
protected |
◆ on_message()
| void DiscordCPP::Discord::on_message |
( |
Message |
message | ) |
|
|
virtual |
called when a Message was received
- Parameters
-
| [in] | message | the Message that was received |
◆ on_ready()
| void DiscordCPP::Discord::on_ready |
( |
User |
user | ) |
|
|
virtual |
called when successfully logged in
- Parameters
-
◆ on_typing_start()
| void DiscordCPP::Discord::on_typing_start |
( |
User |
user, |
|
|
TextChannel |
channel, |
|
|
unsigned int |
timestamp |
|
) |
| |
|
virtual |
called when a User starts typing
- Parameters
-
| [in] | user | the User that started typing |
| [in] | channel | the TextChannel where the USer started typing |
| [in] | timestamp | (unix time) when the User started typing |
◆ on_user_ban()
| void DiscordCPP::Discord::on_user_ban |
( |
User |
user, |
|
|
Guild |
guild |
|
) |
| |
|
virtual |
called when a Member was banned
- Parameters
-
| [in] | user | the User who has been banned |
| [in] | guild | the Guild the User has been banned from |
◆ on_user_join()
| void DiscordCPP::Discord::on_user_join |
( |
Member |
member, |
|
|
Guild |
guild |
|
) |
| |
|
virtual |
called when a User joins a Guild
- Parameters
-
| [in] | member | the User who has joined |
| [in] | guild | the Guild the User has joined |
◆ on_user_remove()
| void DiscordCPP::Discord::on_user_remove |
( |
User |
user, |
|
|
Guild |
guild |
|
) |
| |
|
virtual |
called when a User is removed from a Guild (leave/kick/ban)
- Parameters
-
| [in] | user | the User who has been removed |
| [in] | guild | the Guild the User has been removed from |
◆ on_user_unban()
| void DiscordCPP::Discord::on_user_unban |
( |
User |
user, |
|
|
Guild |
guild |
|
) |
| |
|
virtual |
called when a Member was unbanned
- Parameters
-
| [in] | user | the User who has been unbanned |
| [in] | guild | the Guild the User has been unbanned from |
◆ on_websocket_incoming_message()
| void DiscordCPP::Discord::on_websocket_incoming_message |
( |
const value & |
payload | ) |
|
|
protected |
◆ update_presence()
| pplx::task< void > DiscordCPP::Discord::update_presence |
( |
const string & |
status, |
|
|
Activity |
activity = Activity() , |
|
|
const bool |
afk = false , |
|
|
const int |
shard_id = -1 |
|
) |
| |
updates the presence of user
- Parameters
-
| [in] | status | the new status (see DiscordStatus) |
| [in] | activity | (optional) the Activity |
| [in] | afk | (optional) wether the bot/user is afk or not |
| [in] | shard_id | (optional) the shard whose presence will be updated (use -1 for all shards, default is -1) |
◆ VoiceChannel::connect
◆ _gateways
◆ _guilds
| vector<Guild*> DiscordCPP::Discord::_guilds |
|
protected |
the guilds the user is a member
◆ _num_shards
| unsigned int DiscordCPP::Discord::_num_shards |
|
protected |
◆ _user
| User* DiscordCPP::Discord::_user |
|
protected |
◆ _voice_states
| vector<VoiceState*> DiscordCPP::Discord::_voice_states |
|
protected |
◆ log
| Logger DiscordCPP::Discord::log |
The documentation for this class was generated from the following files: