VValue

Intro
vValue holds stuff that gives a value. It should be used for any and all configuration things. Especially when DCT is usable. Lucifer envisioned a class that could return any arbitrary data type to a hud widget. wrtlprnft implemented it as gHudValue and cleaning it up conceptually. ph added some collection stuff when he needed a class to solve a very similar problem. Luke modularized it and made an expression parser. Nobody really knows how it all works.

Basic Type
You'll want either vValue::Expr::Core::Base* or vValue::Type::BasePtr depending on what your use is, what day of the week you're born on, etc...

Construction
you make the vValue either C++ style:

e = new classname(arguments);

... by parsing a string:

e = vValue::Parser::parse("3 + 2 / 8");

... or by asking the vValue registry to do it for you:

std::vector flags; arglist args; flags.push_back("func"); args.push_back(vValue::Expr::Core::Int(7)); e = vValue::Registry::theRegistry.create(flags, "classname", args);

GetValue
to get the value, you use GetValue:

e->GetValue

Get<>
GetValue returns a Variant, which could be a string, float, integer, you name it! Since you usually have a particular type in mind that you need, it's better to use Get<>:

e->Get

values/vCore
This defines the core stuff needed for vValue.

vValue::Expr::Core
Core expression classes.

Base
This is just your basic expression. It doesn't do much useful. Its value is null.

Number
This template is used to define both Int and Float.

Int
Int holds a literal integer value.

Float
Float holds a literal floating point number value.

String
String holds a literal tString value.

UnaryOp
A base class for unary operators, such as Expr::Logic::Not

BinaryOp
A base class for binary operators, such as Expr::Math::Add

vValue::Type
You can omit the '::Type' if you want. These are types defined for vValue.

Set
TODO: someone who knows, describe it!

BasePtr
It's a shared pointer to an expression object. It automatically deletes when nobody wants it anymore...

Variant
This could be any literal value. Right now, this means either int, float, or tString.

arglist
This is just a deque of BasePtr arguments to pass to the registry for construction of a new expression.

vValue::Creator<>
This template is more or less an automatic factory. It turns constructors into static functions so you can pass a pointer to it.

vValue::Parser
This is the expression parser. It takes a tString and turns it into a tree of vValue expressions.

values/vRegistry
The registry allows expressions to be registered as functions to be called from strings the Parser takes.

Registration
This class is used to register a function:

Registration register_sin("func\nmath", "sin", 1, (Registration::fptr)                          ( ctor::a1* )& Creator::create );

Registry
This is the class for the registry itself, instancised as theRegistry.

theRegistry
This is the registry. It is used to dynamically create expression classes that are registered with it.

ctor
These are static constructor function definitions, for a number of arguments. ctor::a0 is a ctor that has no arguments.

values/vCollection
TODO: I have no idea how this is supposed to work-- ph?

FooPtrOps
TODO

myCol
TODO

GreaterThan
> operator

GreaterOrEquals
>= operator

Equals
== operator

LessOrEquals
<= operator

LessThan
< operator

Compare
<=> operator -- return -1 if <, 0 if ==, or 1 if >

if  (NANs happen to act like that), then it returns NAN.

Condition
a1 ?: a2 !: a3

Not
!arg

Add
+ operator

Subtract
- operator

Multiply

 * operator

Divide
/ operator

Random
A random integer.

Sin
The radial sine of its argument.

values/vebCFunction
This file provides templates for simple C function bindings.

CfZeroary
This template wraps a C function with no arguments.

CfUnary
This template wraps a C function with one argument.

CfBinary
This template wraps a C function with two arguments.

values/vebLegacy
TODO

vValue::Expr::Bindings::MathExpr
TODO