typedef struct { int year; const wchar_t *name; } Foo_args; // parameters
void Foo_func(Foo_args args) {
int x = args.year + 10; // use the argument
}
#define Foo(...) Foo_func((Foo_args){ __VA_ARGS__ })
And this is how you call the function:Foo(.year = 2014, .name = L"Rodrigo");The function calling is clear, and its implementation doesn’t add much noise to the code: I believe the price is payable and the result is worth.
/var/www. I have many subdirectories within it, and I’d like to have one of these subdirectories using clean URLs, specifically becaused I was testing some RESTful API stuff. However, I’ve struggled a bit to make Apache recognize my .htaccess file.sudo vim /etc/apache2/sites-available/defaultWithin the
Directory /var/www directive, change AllowOverride None by AllowOverride All. Then run these two commands:sudo a2enmod rewrite sudo service apache2 restartAnd all of sudden it started working.
bool Func(int p1, int p2, wstring *pErr=nullptr) {
if(false) {
if(pErr) *pErr = L"Error message.";
return false;
}
if(pErr) *pErr = L""; // all good
return true;
}
bool Second(float nn, wstring *pErr=nullptr) {
if(!Func(42, 1337, pErr)) { // will return error message from inner function
return false;
} else if(false) {
if(pErr) *pErr = L"Another error.";
return false;
}
if(pErr) *pErr = L""; // all good
return true;
}
{
wstring err;
if(!Func(42, 1337, &err))
scream(err.c_str());
}
There is no problem with this approach, and I used it for quite some time. It is clear, and one would have no doubts about what is going on. It is, however a bit cumbersome to write all those pErr checks. So at some point I started considering something else.pair<bool, wstring> Func() {
if(false)
return make_pair(false, L"Error description message.");
return make_pair(true, L"");
}
{
pair<bool, wstring> ret = Func();
if(!ret.first)
scream(ret.second.c_str());
}
I never really used this. It doesn’t look clear enough, and the declaration of the pair variable, just to hold the return value, doesn’t amuse me.#include <string>
class Failed {
public:
Failed(bool allGood) : _hasFailed(!allGood) { }
explicit Failed(std::wstring reason) : _hasFailed(true), _reason(reason) { }
explicit Failed(const wchar_t *reason) : _hasFailed(true), _reason(reason) { }
virtual ~Failed() { }
operator bool() const { return _hasFailed; }
const wchar_t* reason() const { return _reason.c_str(); }
private:
bool _hasFailed;
std::wstring _reason;
};
And this is the usage:Failed Func() {
if(false)
return Failed(L"This function failed.");
return true;
}
Failed Second() {
if(Failed f = Func()) { // if Func() returned false
return f; // return from inner function
} else if(false) {
return Failed(L"Another error message.");
}
return true;
}
{
if(Failed f = Second())
scream(f.reason());
}
This approach looks a lot elegant to me. It’s clean, allows the chaining of error messages, and it even allows the inheriting of the Failed class to add more specific error data – although I never really needed this._hasFailed member, which holds a reversed boolean value of the object meaning: if there’s a success, it’s false; if there’s a failure, it’s true. I implemented it this way so that I could use a declaration of the class within an if statement, with no need to declare a variable just to hold the result, as I did on the previous example when I returned a standard pair. Also, it explains why I chose the name “Failed” instead of something like “BigBool”: to explicit the idea of a failure being handled by the if.
About 2 years ago I was suffering from some wrist pain, due to countless hours of computer work with an ordinary mouse. I started searching for some device to relieve the pain, and after test several gadgets, I came across the Logitech Trackman Wheel. It’s a trackball which sphere is moved with the thumb, leaving the whole hand resting on the desk. And it’s absolutely great, precise, comfortable, I could use that thing for hours without any signs of tiring.C:\Users\Rodrigo\Documents\Visual Studio 2013\Templates\ProjectTemplatesIn addition to the project settings, I also put in the template a subdirectory called “src”, my very basic main.cpp file, which contains my wWinMain entry point. It seems that I’ll never have to write it again.
template<typename T> class Ptr {
public:
Ptr() : _ptr(NULL), _counter(NULL) { }
Ptr(T *ptr) : _ptr(NULL), _counter(NULL) { operator=(ptr); }
Ptr(const Ptr& other) : _ptr(NULL), _counter(NULL) { operator=(other); }
~Ptr() {
if(_counter && !--(*_counter)) {
delete _ptr; _ptr = NULL;
delete _counter; _counter = NULL;
}
}
Ptr& operator=(T *ptr) {
this->~Ptr();
if(ptr) {
_ptr = ptr; // take ownership
_counter = new int(1); // start counter
}
return *this;
}
Ptr& operator=(const Ptr& other) {
if(this != &other) {
this->~Ptr();
_ptr = other._ptr;
_counter = other._counter;
if(_counter) ++(*_counter);
}
return *this;
}
bool isNull() const { return _ptr == NULL; }
T& operator*() { return *_ptr; }
const T* operator->() const { return _ptr; }
T* operator->() { return _ptr; }
operator T*() const { return _ptr; }
private:
T *_ptr;
int *_counter;
};
Example usage:struct When {
int month;
int day;
};
Ptr<When> GetLunchTime()
{
Ptr<When> ret = new When(); // alloc pointer to be owned
ret->month = 12;
ret->day = 16;
return ret;
}
int main()
{
Ptr<When> lunchTime = GetLunchTime();
// ...
// no need to delete lunchTime
return 0;
}
It works fine, but with the implementation of move semantics – which is truly great –, it seems that I don’t need it anymore. So I’m publishing it here for historical reasons.
Ptr<String> Function() {
Ptr<String> ret = new String();
return ret;
}
This worked perfectly fine. What bugged me was that two more allocations are needed on this approach: the internal smart pointer instance counter, and the pointer itself. These two allocations, of course, are summed up to the internal String array allocation, so I ended up with three memory allocations for a trivial string return. That sounded too much to my optimization paranoia.String Function() {
String ret;
return ret;
}
My return object is allocated on the stack, not heap-allocated, so we have saved one allocation. And since I’m not returning a pointer – but rather returning the object my value – we don’t need the smart pointer anymore, so we saved another allocation. In the end, we shrinked down from three to only one single allocation, the internal string array itself. With the move semantics implemented, the internal string array just flies from an object into another, without cloning the whole array.map argument is the map object you’re working upon, and lon and lat are floating point numbers.function Geo(map, lat, lon) {
return new OpenLayers.LonLat(lon, lat)
.transform(new OpenLayers.Projection('EPSG:4326'),
map.getProjectionObject());
}
// Example usage:
var map = new OpenLayers.Map('myMapDivId');
map.addLayer(new OpenLayers.Layer.OSM());
var coor = Geo(map, -5.773274, -35.204948);
map.setCenter(coor, 8);
Second, the image (icon) plotting. When you plot an image at a given point, this image is centered at that point. I wanted to plot an image of a pushpin, which points at the wrong location if centered – the very end of the pushpin will point to a location below the center of the image. It had to be moved above, so that the bottom of the image was exactly over the point.img argument is a valid image URL, cx and cy are the size of the image in pixels, and bottomOffset is a boolean value. The function is asychronous and waits the image to be loaded; use the onDone callback, which receives the new marker as argument.function PlotMarker(map, img, lat, lon, bottomOffset, onDone) {
var imgObj = new Image();
imgObj.src = img;
imgObj.onload = function() {
var sz = new OpenLayers.Size(imgObj.width, imgObj.height);
var off = new OpenLayers.Pixel(-(sz.w / 2),
bottomOffset ? -sz.h : -(sz.w / 2));
var ico = new OpenLayers.Icon(img, sz, off);
if(onDone !== undefined && onDone !== null)
onDone(new OpenLayers.Marker(Geo(map, lat, lon), ico));
};
}
// Example usage:
var map = new OpenLayers.Map('myMapDivId');
map.addLayer(new OpenLayers.Layer.OSM());
var markers = new OpenLayers.Layer.Markers('Markers');
map.addLayer(markers);
PlotMarker(map, 'pushpin.png', -5.773274, -35.204948,
true, // it's a pushpin, I want it bottom-aligned
function(mk) {
markers.addMarker(mk);
});
Below you have a fully functional web application composed of three files, which displays an OpenStreetMap map at the whole page, loads points from a separated JSON file, and renders it accordingly. There’s no server-side processing involved, but the JSON file could easily be something processed by the server, which would load the data from some sort of database. I used jQuery library to handle the mouseover event which shows the popup over the images, but it’s not really necessary if you want to use something else.<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8"/>
<title>Rodrigo's map</title>
<style>
* { -moz-box-sizing:border-box; -webkit-box-sizing:border-box; box-sizing:border-box; }
body { margin:0; font:10pt Arial; color:#242424; }
#mapArea { position:absolute; width:100%; height:100%; }
</style>
<script src="http://ajax.aspnetcdn.com/ajax/jQuery/jquery-2.0.3.min.js"></script>
<script src="http://openlayers.org/api/2.13.1/OpenLayers.js"></script>
<script src="index.js"></script>
</head>
<body>
<div id="mapArea"></div>
</body>
</html>
2) index.jsfunction PlotData(divId, data) {
function Geo(map, lat, lon) {
return new OpenLayers.LonLat(lon, lat)
.transform(new OpenLayers.Projection('EPSG:4326'), map.getProjectionObject());
}
function PlotMarker(map, img, lat, lon, bottomOffset, onDone) {
var imgObj = new Image();
imgObj.src = img;
imgObj.onload = function() {
var sz = new OpenLayers.Size(imgObj.width, imgObj.height);
var off = new OpenLayers.Pixel(-(sz.w / 2),
bottomOffset ? -sz.h : -(sz.w / 2));
var ico = new OpenLayers.Icon(img, sz, off);
if(onDone !== undefined && onDone !== null)
onDone(new OpenLayers.Marker(Geo(map, lat, lon), ico));
};
}
var map = new OpenLayers.Map(divId);
map.addLayer(new OpenLayers.Layer.OSM());
map.setCenter(Geo(map, data.center[0], data.center[1]), data.zoom);
var markers = new OpenLayers.Layer.Markers('Markers');
map.addLayer(markers);
var $map = $('#'+divId),
$det = $('<div></div>').css({
'position':'absolute',
'padding':'0 4px',
'display':'none',
'box-shadow':'2px 2px 3px #999',
'background-color':'rgba(255,255,255,.85)',
'border':'1px solid #AAA'
}).appendTo('body');
$.each(data.points, function(i, pt) {
PlotMarker(map, pt.icon, pt.coor[0], pt.coor[1], true, function(mk) {
markers.addMarker(mk);
mk.events.on({
mouseover: function(ev) {
$det.html(pt.text).css({
left: (ev.pageX < $(document).width() / 2) ?
ev.pageX+'px' : (ev.pageX - $det.outerWidth())+'px',
top: (ev.pageY < $(document).height() / 2) ?
ev.pageY+'px' : (ev.pageY - $det.outerHeight())+'px',
display: 'block'
});
$map.css('cursor', 'pointer');
},
mouseout: function(ev) {
$det.empty().css('display', 'none');
$map.css('cursor', 'auto');
}
});
});
});
}
$(document).ready(function() {
$.getJSON('data.json', function(data) {
PlotData('mapArea', data);
});
});
3) data.json – assumes image “pushpin.png” exists{
"center": [ -5.797942,-35.211782 ],
"zoom": 14,
"points": [
{
"coor": [ -5.799500,-35.21951 ],
"icon": "pushpin.png",
"text": "First point<br/>Anything here"
},
{
"coor": [ -5.790982,-35.19409 ],
"icon": "pushpin.png",
"text": "Other <b>point</b> here"
},
{
"coor": [ -5.802083,-35.20877 ],
"icon": "pushpin.png",
"text": "Something else<br/>placed here"
}
]
}
Enjoy.