nix-super/src/libutil/types.hh

#pragma once


#include "ref.hh"

#include <list>
#include <set>
#include <map>


namespace nix {

using std::list;
using std::set;
using std::vector;
using std::string;

typedef list<string> Strings;
typedef set<string> StringSet;
typedef std::map<string, string> StringMap;

/* Paths are just strings. */

typedef string Path;
typedef list<Path> Paths;
typedef set<Path> PathSet;


/* Helper class to run code at startup. */
template<typename T>
struct OnStartup
{
    OnStartup(T && t) { t(); }
};


}
Use "#pragma once" to prevent repeated header file inclusion 2012-07-18 21:59:03 +03:00			`#pragma once`
* Use a proper namespace. * Optimise header file usage a bit. * Compile the parser as C++. 2006-09-05 00:06:23 +03:00
Include config.h before any other header "config.h" must be included first, because otherwise the compiler might not see the right value of _FILE_OFFSET_BITS. We've had this before; see 705868a8a96a10f70e629433cfffc2d5cd2703eb. In this case, GCC would compute a different address for ‘settings.useSubstitutes’ in misc.cc because of the off_t in ‘settings’. Reverts 3854fc9b42d16b810f62b64194b699033b03aaf1. http://hydra.nixos.org/build/3016700 2012-09-11 21:45:42 +03:00
Move ref<t> into a separate header 2016-02-23 14:53:31 +02:00			`#include "ref.hh"`

* Use a proper namespace. * Optimise header file usage a bit. * Compile the parser as C++. 2006-09-05 00:06:23 +03:00			`#include <list>`
			`#include <set>`
Add a Config class to simplify adding configuration settings The typical use is to inherit Config and add Setting<T> members: class MyClass : private Config { Setting<int> foo{this, 123, "foo", "the number of foos to use"}; Setting<std::string> bar{this, "blabla", "bar", "the name of the bar"}; MyClass() : Config(readConfigFile("/etc/my-app.conf")) { std::cout << foo << "\n"; // will print 123 unless overriden } }; Currently, this is used by Store and its subclasses for store parameters. You now get a warning if you specify a non-existant store parameter in a store URI. 2017-04-13 16:55:38 +03:00			`#include <map>`
* Use a proper namespace. * Optimise header file usage a bit. * Compile the parser as C++. 2006-09-05 00:06:23 +03:00
Fix build on gcc < 4.7 2014-10-20 19:15:50 +03:00
* Use a proper namespace. * Optimise header file usage a bit. * Compile the parser as C++. 2006-09-05 00:06:23 +03:00			`namespace nix {`

			`using std::list;`
			`using std::set;`
			`using std::vector;`
fixes to merged code 2020-05-12 00:52:15 +03:00			`using std::string;`
Make fmt() non-recursive 2017-05-11 18:06:07 +03:00
formatting and a few minor changes 2020-05-14 00:56:39 +03:00			`typedef list<string> Strings;`
			`typedef set<string> StringSet;`
			`typedef std::map<string, string> StringMap;`
* Use a proper namespace. * Optimise header file usage a bit. * Compile the parser as C++. 2006-09-05 00:06:23 +03:00
			`/* Paths are just strings. */`
all things error to error.hh 2020-04-24 23:57:51 +03:00
formatting and a few minor changes 2020-05-14 00:56:39 +03:00			`typedef string Path;`
* Use a proper namespace. * Optimise header file usage a bit. * Compile the parser as C++. 2006-09-05 00:06:23 +03:00			`typedef list<Path> Paths;`
			`typedef set<Path> PathSet;`

Don't interpret strings as format strings Ludo reported this error: unexpected Nix daemon error: boost::too_few_args: format-string refered to more arguments than were passed coming from this line: printMsg(lvlError, run.program + ": " + string(err, 0, p)); The problem here is that the string ends up implicitly converted to a Boost format() object, so % characters are treated specially. I always assumed (wrongly) that strings are converted to a format object that outputs the string as-is. Since this assumption appears in several places that may be hard to grep for, I've added some C++ type hackery to ensures that the right thing happens. So you don't have to worry about % in statements like printMsg(lvlError, "foo: " + s); or throw Error("foo: " + s); 2014-03-28 17:59:26 +02:00
Backport libfetchers from the flakes branch This provides a pluggable mechanism for defining new fetchers. It adds a builtin function 'fetchTree' that generalizes existing fetchers like 'fetchGit', 'fetchMercurial' and 'fetchTarball'. 'fetchTree' takes a set of attributes, e.g. fetchTree { type = "git"; url = "https://example.org/repo.git"; ref = "some-branch"; rev = "abcdef..."; } The existing fetchers are just wrappers around this. Note that the input attributes to fetchTree are the same as flake input specifications and flake lock file entries. All fetchers share a common cache stored in ~/.cache/nix/fetcher-cache-v1.sqlite. This replaces the ad hoc caching mechanisms in fetchGit and download.cc (e.g. ~/.cache/nix/{tarballs,git-revs*}). This also adds support for Git worktrees (c169ea59049f861aaba429f48b828d0820b74d1d). 2020-03-30 17:04:18 +03:00			`/* Helper class to run code at startup. */`
			`template<typename T>`
			`struct OnStartup`
			`{`
			`OnStartup(T && t) { t(); }`
			`};`


* Use a proper namespace. * Optimise header file usage a bit. * Compile the parser as C++. 2006-09-05 00:06:23 +03:00			`}`