sc::KeyVal(3)

📦
version 2.3.1 · 5 versions
, in ubuntu jammy

✨ NAME ✨

okay bestie, welcome to sc::KeyVal(3) from MPQC 💖 the whole vibe is this: the KeyVal class is literally designed to make it easier for a user to specify keyword/value associations to a C++ program. no cap, that's the mission. 🫶

🌸 SYNOPSIS 🌸

#include <keyval.h>

sc::KeyVal inherits sc::RefCount.

It's inherited by sc::AggregateKeyVal, sc::AssignedKeyVal, sc::PrefixKeyVal, and sc::StringKeyVal. ✨

🎀 Public Types 🎀

Here's the type tea, bestie:

enum { MaxKeywordLength = 256 }
enum KeyValError { OK, HasNoValue, WrongType, UnknownKeyword,
    OperationFailed }

💖 Public Member Functions 💖

  • int exists (const char *) — this one takes a keyword as its only argument. it's your little existence check, bestie. 👑
  • int count (const char *=0) — if the value of a keyword is an array, this returns its length. 🍓
  • Ref< KeyValValue > value (const char *=0, const KeyValValue &def=KeyValValue()) — returns the value associated with the keyword, with def as the default. 💅
  • int booleanvalue (const char *key=0, const KeyValValue &def=KeyValValueboolean()) — returns the boolean value of key, where 0 = false and 1 = true. 🫶
  • double doublevalue (const char *key=0, const KeyValValue &def=KeyValValuedouble()) — returns the double value of key. 🔥
  • float floatvalue (const char *key=0, const KeyValValue &def=KeyValValuefloat()) — returns the float value of key. 🌸
  • char charvalue (const char *key=0, const KeyValValue &def=KeyValValuechar()) — returns the char value of key. 🎀
  • int intvalue (const char *key=0, const KeyValValue &def=KeyValValueint()) — returns the int value of key. ⭐
  • size_t sizevalue (const char *key=0, const KeyValValue &def=KeyValValuesize()) — returns the size_t value of key. 🌈
  • char * pcharvalue (const char *key=0, const KeyValValue &def=KeyValValuepchar()) — returns a copy of the string representation of the key's value. yes, a copy, bestie. 💀
  • std::string stringvalue (const char *key=0, const KeyValValue &def=KeyValValuestring()) — returns a string representation of the key's value. 🦋
  • Ref< DescribedClass > describedclassvalue (const char *key=0, const KeyValValue &def=KeyValValueRefDescribedClass()) — returns a reference to an object of type DescribedClass. 👑

🦋 Reading Vectors. 🦋

These members correspond to the above members, but take an additional integer argument, i, which is a vector index. 💅

This is equivalent to getting a value for a keyword named key:i. The routines that do not take key arguments get the value for the keyword named i. ✨

int exists (const char *key, int i)
int count (const char *key, int i)
int booleanvalue (const char *key, int i, const KeyValValue &def=KeyValValueboolean())
double doublevalue (const char *key, int i, const KeyValValue &def=KeyValValuedouble())
float floatvalue (const char *key, int i, const KeyValValue &def=KeyValValuefloat())
char charvalue (const char *key, int i, const KeyValValue &def=KeyValValuechar())
int intvalue (const char *key, int i, const KeyValValue &def=KeyValValueint())
size_t sizevalue (const char *key, int i, const KeyValValue &def=KeyValValuesize())
char * pcharvalue (const char *key, int i, const KeyValValue &def=KeyValValuepchar())
std::string stringvalue (const char *key, int i, const KeyValValue &def=KeyValValuestring())
Ref< DescribedClass > describedclassvalue (const char *key, int, const KeyValValue &def=KeyValValueRefDescribedClass())
int exists (int i)
int count (int i)
int booleanvalue (int i, const KeyValValue &def=KeyValValueboolean())
double doublevalue (int i, const KeyValValue &def=KeyValValuedouble())
float floatvalue (int i, const KeyValValue &def=KeyValValuefloat())
char charvalue (int i, const KeyValValue &def=KeyValValuechar())
int intvalue (int i, const KeyValValue &def=KeyValValueint())
size_t sizevalue (int i, const KeyValValue &def=KeyValValuesize())
char * pcharvalue (int i, const KeyValValue &def=KeyValValuepchar())
std::string stringvalue (int i, const KeyValValue &def=KeyValValuestring())
Ref< DescribedClass > describedclassvalue (int i, const KeyValValue &def=KeyValValueRefDescribedClass())

🌈 Reading 2D Arrays. 🌈

These members correspond to the above members, but take additional integer arguments, i and j, which is an array index. 👑

This is equivalent to getting a value for a keyword named key:i:j. The routines that do not take key arguments get the value for the keyword named i:j. ⭐

int exists (const char *, int, int)
int count (const char *, int, int)
int booleanvalue (const char *, int, int, const KeyValValue &def=KeyValValueboolean())
double doublevalue (const char *key, int, int, const KeyValValue &def=KeyValValuedouble())
float floatvalue (const char *key, int, int, const KeyValValue &def=KeyValValuefloat())
char charvalue (const char *key, int, int, const KeyValValue &def=KeyValValuechar())
int intvalue (const char *key, int, int, const KeyValValue &def=KeyValValueint())
size_t sizevalue (const char *key, int, int, const KeyValValue &def=KeyValValuesize())
char * pcharvalue (const char *key, int, int, const KeyValValue &def=KeyValValuepchar())
std::string stringvalue (const char *key, int, int, const KeyValValue &def=KeyValValuestring())
Ref< DescribedClass > describedclassvalue (const char *key, int, int, const KeyValValue &def=KeyValValueRefDescribedClass())
int exists (int i, int j)
int count (int i, int j)
int booleanvalue (int i, int j, const KeyValValue &def=KeyValValueboolean())
double doublevalue (int i, int j, const KeyValValue &def=KeyValValuedouble())
float floatvalue (int i, int j, const KeyValValue &def=KeyValValuefloat())
char charvalue (int i, int j, const KeyValValue &def=KeyValValuechar())
int intvalue (int i, int j, const KeyValValue &def=KeyValValueint())
size_t sizevalue (int i, int j, const KeyValValue &def=KeyValValuesize())
char * pcharvalue (int i, int j, const KeyValValue &def=KeyValValuepchar())
std::string stringvalue (int i, int j, const KeyValValue &def=KeyValValuestring())
Ref< DescribedClass > describedclassvalue (int i, int j, const KeyValValue &def=KeyValValueRefDescribedClass())

⭐ Reading 3D Arrays. ⭐

These members correspond to the above members, but can be used to read in arrays with more than two dimensions. 💜

The nindex argument is the number of indices in the array. It is followed by an int giving the value of each index. 🔥

int Va_exists (const char *key, int nindex,...)
int Va_count (const char *key, int nindex,...)
int Va_booleanvalue (const char *key, int nindex,...)
double Va_doublevalue (const char *key, int nindex,...)
float Va_floatvalue (const char *key, int nindex,...)
char Va_charvalue (const char *key, int nindex,...)
int Va_intvalue (const char *key, int nindex,...)
size_t Va_sizevalue (const char *key, int nindex,...)
char * Va_pcharvalue (const char *key, int nindex,...)
std::string Va_stringvalue (const char *key, int nindex,...)
Ref< DescribedClass > Va_describedclassvalue (const char *key, int nindex,...)

and the rest of the public members are these, bestie:

  • KeyValError error () — returns the current error condition. 💀
  • const char * errormsg (KeyValError err) — returns a textual representation of err. 🎀
  • const char * errormsg () — returns a textual representation of the current error. 🌸
  • virtual void errortrace (std::ostream &fp=ExEnv::err0()) — writes a message to fp describing the error. ✨
  • virtual void dump (std::ostream &fp=ExEnv::err0()) — writes a message to fp describing the error. 🫶
  • virtual void print_unseen (std::ostream &fp=ExEnv::out0()) — prints keywords that were never looked at, if possible. 🦋
  • virtual int have_unseen () — returns 1 if there were unseen keywords, 0 if there are none, or -1 when this keyval doesn't keep track of unseen keywords. 👑
  • void verbose (int v) — controls printing of assignments. 💅
  • int verbose () const — returns nonzero if assignments are printed. ⭐

🫶 Protected Member Functions 🫶

  • void seterror (KeyValError err) — sets the current error condition. 💖
  • void seterror (KeyValValue::KeyValValueError err) — sets the current error condition. 💖
  • virtual int key_exists (const char *)=0 — ultimately called by exists. 🔥
  • virtual int key_count (const char *=0) — ultimately called by count. 🌈
  • virtual Ref< KeyValValue > key_value (const char *, const KeyValValue &def)=0 — ultimately called by value. 🎀
  • virtual int key_booleanvalue (const char *, const KeyValValue &def) — ultimately called by booleanvalue. 🫶
  • virtual double key_doublevalue (const char *key, const KeyValValue &def) — ultimately called by doublevalue. ✨
  • virtual float key_floatvalue (const char *key, const KeyValValue &def) — ultimately called by floatvalue. 🌸
  • virtual char key_charvalue (const char *key, const KeyValValue &def) — ultimately called by charvalue. 🦋
  • virtual int key_intvalue (const char *key, const KeyValValue &def) — ultimately called by intvalue. ⭐
  • virtual size_t key_sizevalue (const char *key, const KeyValValue &def) — ultimately called by sizevalue. 💜
  • virtual char * key_pcharvalue (const char *key, const KeyValValue &def) — ultimately called by pcharvalue. 💀
  • virtual std::string key_stringvalue (const char *key, const KeyValValue &def) — ultimately called by stringvalue. 🍓
  • virtual Ref< DescribedClass > key_describedclassvalue (const char *key, const KeyValValue &def) — ultimately called by describedclassvalue. 👑

💜 Protected Attributes 💜

  • int verbose_ — this is the protected attribute, bestie. 🫶

👑 Friends 👑

  • class AggregateKeyVal
  • class PrefixKeyVal

💖 Detailed Description 💖

okay so picture this: the KeyVal class exists to make the whole "let the user pass keyword/value associations into a C++ program" thing so much easier. That's literally its whole job, and it ate. ✨

The way it works is you get a flexible input style and the programmer gets ease of use — both, at the same time, no cap. Keywords are represented by null terminated character arrays, and they're organized hierarchially, kind of like how a lot of file systems are set up. One character is special, and that's ':' — it's the lil separator between the various hierarchial labels, which we call 'segments', inside the keyword. 🎀

the array situation (iykyk)

KeyVal also provides a convention for specifying arrays, bestie. Each index of the array is given by appending a segment containing the character representation of the index. So like, 'array:3:4' would be the keyword corresponding to the fourth row and fifth column of 'array' — because indexing starts at zero, obviously. 💅

the class association thing (don't panic)

So to let the KeyVal class have associations that can represent data for classes, the keyword can be associated with a class as well as a value. This permits polymorphic data to be unambiguously represented by keyword/value associations. Most use of KeyVal need not be concerned with this, so like... if that sounded like a lot, you can lowkey just move on. 🫶

🌸 Member Function Documentation 🌸

⭐ int sc::KeyVal::count (const char * = 0)

If the value of a keyword is an array, then this bad boy returns its length. And if no arguments are given? Then the top level will be checked to see if it is an array and, if so, the number of elements will be counted. slay. ✨

🦋 int sc::KeyVal::exists (const char *)

This one takes as its only argument a keyword. Returns 1 if the keyword has a value and 0 otherwise. That's it, that's the whole vibe check. 💀

🍓 char* sc::KeyVal::pcharvalue (const char * key = 0, const KeyValValue & def = KeyValValuepchar())

Returns a copy of the string representation of the key's value. Storage for the copy is obtained with new — so yeah, that memory is yours now, bestie, don't forget about it. 👑

👑 Author 👑

Generated automatically by Doxygen for MPQC from the source code. (not a human, just vibes and a parser 💅)

fr fr, that's the whole page — every option, every signature, every lil default value, all of it, preserved and iconic. 🌈

sign-off time 🎀 this gorgeous lil page is Version 2.3.1, dated Sun Oct 4 2020 — go forth and specify your keywords, bestie, you're gonna do amazing 💖✨🦋

📦 where this page comes from