Note: this example requires the database to already exist. EF automatic creation/migrations will not work.
Db configuration class, this ensures the correct connection factory is used. My testing found this was the only way to get it set, various connection string formats were ignored/overridden at runtime.
1 2 3 4 5 6 7 8 9 10 11 | |
Next define a context class decorated with the custom db config attribute. Ensure the default schema is set to “public” (or the relevant schema name).
Key Points:
Some sort of case conversion will likely need to made in the OnModelCreating method, in my case I made all column names lowercase and did the necessary column name transformation there. For table names I used decorator attributes on the entity classes.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | |
After running the automated update command from the Xamarin Studio OSX build menu I encountered the following error on subsequent builds:
1 2 | |
If you get a similar error it will probably be necessary to:
Rebuild.
If the issue still persists (like in my case) and you are using Xamarin Studio you may have to manually delete the old component package files from your file system then reinstall them after you are sure they have been wiped. Xamarin studio can store them in multiple locations depending on platform be sure to check: https://kb.xamarin.com/customer/portal/articles/1865772-where-are-the-components-stored-on-my-machine- to find the location on your machine.
One other thing to note is the compiled binary size of your app will probably double because the resulting package now contains both 32 and 64 bit versions.
]]>1 2 3 4 5 6 7 8 | |
This won’t compile, the method signature for Equal takes interface{} parameters. Understandably the compiler can’t figure it out.
After checking the mailing list it turns out the compiler is smart enough to map multiple return values to function params when their types and order match. e.g:
1 2 3 4 5 6 7 8 9 10 | |
With this behavior in mind we can write a shim function to map multiple return values to a slice of values that the assert function can compare. Here is a 2 value shim:
1 2 3 4 | |
It can be used like so
1 2 3 4 5 6 | |
Now shorten the name and create shims for different number of return values.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | |
And finally here is a complete working example.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 | |
1 2 | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 | |
1 2 3 4 5 6 7 8 9 | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 | |
1
| |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 | |
1 2 3 4 5 6 7 8 9 10 11 | |
1
| |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 | |
Nupic is Numenta’s current open source implementation of Jeff Hawkin’s hierarchical temporal memory(HTM) model. It currently consists of the CLA (cortical learning algorithm) which is a single stage/layer of the HTM implemented in a mix of python and C++.
In an effort to better understand the difference between the current implementation and the whitepaper I decided to try and port the spatial and temporal poolers to Go. Porting line by line gave me the opportunity to understand the design better as well as it’s dependencies: python, numpy, etc…
One of the more difficult parts of this project was interpreting the numpy expressions and translating them into a statically typed language. A few nested numpy expressions can easily end up being 10 of lines of Go.
The result is 2 simple APIs for the spatial and temporal pooler which are go gettable.
1 2 | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 | |
You can grab the code @ https://github.com/zacg/htm
]]>The encoding algorithm is based on the method described in this Nature paper: http://www.nature.com/nature/journal/v494/n7435/full/nature11875.html . Pseudo code and details can be found here: http://www.nature.com/nature/journal/vaop/ncurrent/extref/nature11875-s2.pdf
Usage Example:
1 2 3 | |
The resulting string is a valid DNA sequence.
Sequences can be decoded back to human readable text the same way:
1 2 3 | |
Source on github: https://github.com/zacg/dna
]]>Because Cerebro is a webapp built on mongodb and python it requires a bit of work get setup. To make it easier for newcomers to get up and running quickly I created a dockerfile containing all the dependencies required to run Cerebro. Once the docker image is built Cerebro can be run with one command. (Eventually users will be able to pull an official built image from dockers index)
The Dockerfile is now located in the Cerebro repository: https://github.com/numenta/nupic.cerebro/blob/master/Dockerfile
To build the docker image:
1
| |
To run Cerebro on port: 1955:
1
| |
Simply navigate to http://localhost:1955 to start using Cerebro. For an introductory video checkout: http://youtu.be/WQWU1K5tE5o
]]>Here is what worked for me: after creating a layout named “CustomHeader.xml” I added the following lines to my activity OnCreate method:
1 2 3 4 5 6 7 | |
I then modified my androidmanifiest.xml and style.xml files to configure a custom theme that inherits from the oridinal halo theme but removes the action bar.
1 2 3 | |
1 2 3 4 5 6 | |
If you don’t already have a styles.xml file, it should be created in /resources/values/
If you try setting a custom header/title without removing the actionbar you will get the following runtime exception: “Cannot combine custom title with other title features”
]]>After some quick googling I found a NuGet package that seemed to be fairly well maintained and had a modest amount of users according to the NuGet download stats. NuGet Package here: http://www.nuget.org/packages/log4net.Appender.Azure/ or type the following in package manager console:
1
| |
However I immediately ran into a few issues, first problems building it with my project as it was built with dependencies on older frameworks such as log4net. Additionally when running the table appender in a real application with multiple concurrent loggers I began to get errors related to the way it submitted batch inserts to the storage service.
I was able to fork the NuGet project on github, update it’s dependencies, and fix the batch processing issue, you can find my branch here: https://github.com/zacg/log4net.Azure I have submitted a pull request for these changes, hopefully they will appear in the next NuGet package release.
Once referenced just choose your preferred storage method and set your connection string like so:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | |
If you ever have to debug log4net appenders here are a few snippets that may help you. The first is a function to flush the log buffers. The second turns on log4net debug logging, it will log to system.diagnostic.trace, just place the app setting in your config file. And the last snippet is just a setting to write your trace logs to file, again place in your config file.
1 2 3 4 5 6 7 8 9 10 11 12 13 | |
1 2 3 | |
1 2 3 4 5 6 7 8 9 10 | |
And finally a list of the errors encountered and fixed to help out random googlers.
I ran into a few roadblocks along the way but ended up with a working log4net appender that can write logs to Azure storage services with a few simple configuration settings. If you have any comments feel free to share below.
Source Code Here: https://github.com/zacg/log4net.Azure
]]>1 2 3 4 5 | |
This check will enable you to write fewer, more reusable form templates. The following changes to the default bootstrap template included with backbone forms allows you to include form submit and cancel buttons by setting a template data flag.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | |
I had two options: I could implement custom marshal interfaces for every data entity struct, or I could write a function that reflects over the object graph after it has been built by the json marshaler and run my initialization function against any new/unintitalized base entity structs. I decided to go with the later option.
There are a few key functions needed to achieve the method described above, mainly: reflecting over an object to get a list of it’s fields, checking the type of the reflected field against your base struct, checking if the reflected field value is uninitialized or in the case of a pointer nil, and finally setting the value of an empty field to an initialized struct.
Here are some code examples:
1 2 3 4 5 6 7 8 9 10 | |
Reflect over object and get list of fields
1 2 3 4 5 6 7 8 | |
Compare reflected type
1 2 3 | |
Checking for uninitialized/empty struct
1 2 3 | |
Checking for nil pointer - if you are using pointers you may need to check for a nil pointer rather than an uninitialized struct.
1 2 3 | |
Finally once an empty field is found set it to an initialized Entity struct
1 2 | |
With the above snippets you can easily build a custom function for iterating over your object graph and initialize empty structs.
]]>After reviewing the Swig project commit log and noticing some fixes for Go related issues, I remembered I had installed Swig from the debian aptitude manager. Sure enough after running “swig -version” my swig version was at 2.0.7 (the current version at this time of writing was 2.0.10). 2.0.7 lacks many bug fixes related to Go. Downloading and installing 2.0.10 from the Swig website solved my memory issues.
Solution:
1 2 | |
My fork can be found on github at: https://github.com/zacg/geoserver-csharp
]]>The code:
And to use it:
1
| |
Use it with a custom id field:
1
| |
First I moved all the commands that needed to run with sudo into a single make file like the following, mine was called InstallLib.make:
1 2 3 4 5 6 7 | |
Next in Qt Creator with your project open, goto the project section, add a new “custom process” build step. In the command field type: “ssh-askpass” this program will popup a widget to enter the sudo password when executed. In the build step arguments field enter: “Sudo Password | sudo -S make -f InstallLib.make”. This will make the ssh-askpass program execute the “InstalledLib.make” make file when a correct sudo password is provided.
If you prefer not to use the GUI, you could also edit your projects .user file and add some xml similar to the following:
1 2 3 4 5 6 7 8 9 | |
It’s pretty straight forward, pass in the length (n) of binary digits and it will return an array of all possible combinations as boolean values.
]]>Usage is simple, when the 2nd paramater is set to true, all fieldnames will start with a lowercase letter(other capitalization remains unchanged):
1
| |
The source code can be downloaded from github: https://github.com/zacg/goutils
And here is some boilerplate code to use it in a Revel controller:
]]>
The following is a brief tutorial to guide you through wrapping a C++ class with a Go package which can be called from any Go program.
Start by installing GO and SWIG if not already installed
1 2 | |
Update: The debian package is out of date and lacking many go related fixes, it is best to install current SWIG release from SWIG website: http://swig.org
I also recommend installing golang from source as some of the following commands only work with go 1.1 and up. http://golang.org/doc/install/source
Once everything in installed the first step is to define a module file which will tell the SWIG tool what code in the C++ project to expose in the resulting GO package. We’ll assume your project is object oriented with cpp/header files for each class, when this is the case we can just include the desired header files in our SWIG module.
We will pretend our C++ project is a dynamically linked shared library called “simplelib” and contains the following files:
1
2
3
simpleclass.h
simpleclass.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef SIMPLECLASS_H
#define SIMPLECLASS_H
#include <iostream>
#include <vector>
class SimpleClass
{
public:
SimpleClass(){};
std::string hello();
void helloString(std::vector<std::string> results);
void helloBytes(std::vector<char> results);
};
#endif
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include "simpleclass.h"
std::string SimpleClass::hello(){
return "world";
}
void SimpleClass::helloString(std::vector<std::string> results){
results->push_back("world");
}
void SimpleClass::helloBytes(std::vector<char> results){
results->push_back('w');
results->push_back('o');
results->push_back('r');
results->push_back('l');
results->push_back('d');
}
We will add a module file called simplelib.swig. Inside we include the simpleclass.h header, this will instruct the SWIG tool to generate wrapping code for this class allowing us to use it in GO.
1
2
3
%module simplelib //name of the resulting GO package
%include "simpleclass.h"
If your wrapped class(es) are simple and use primitive types the above swig file should suffice, SWIG will translate the following primitive types to the specified Go types
| C/C++ type | Go type |
|---|---|
| bool | bool |
| char | byte |
| signed char | int8 |
| unsigned char | byte |
| short | int16 |
| unsigned short | uint16 |
| int | int |
| unsigned int | uint |
| long | int32 or int64, depending on -long-type-size |
| unsigned long | uint32 or uint64, depending on -long-type-size |
| long long | int64 |
| unsigned long long | uint64 |
| float | float32 |
| double | float64 |
| char * char [] |
string |
If your target code contains non-primitive types you have a bit more work to do. SWIG includes headers to help with common non primitive types like string and vector from the standard library. Vectors bring up another issue because they use templates, template types have to be explicitly defined in your SWIG mapping file. A class that uses std::string and std::vector might look like the following:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
%module simplelib
%include <typemaps.i>
%include "std_string.i"
%include "std_vector.i"
// This will create 2 wrapped types in Go called
// "StringVector" and "ByteVector" for their respective
// types.
namespace std {
%template(StringVector) vector<string>;
%template(ByteVector) vector<char>;
}
%include "simpleclass.h"
The following definitions are included with the SWIG library, go here for full reference
| C++ class | C++ Library file | SWIG Interface library file |
|---|---|---|
| std::deque | deque | std_deque.i |
| std::list | list | std_list.i |
| std::map | map | std_map.i |
| std::pair | utility | std_pair.i |
| std::set | set | std_set.i |
| std::string | string | std_string.i |
| std::vector | vector | std_vector.i |
Next we need to generate the necessary C++ wrapper code to allow Go to bind to it.
Update: With the official release of Go 1.2, the go build tool now recognizes SWIG files. The following steps are not necessary but may still be useful for users with more complicated build systems.
If you are using Go 1.2 simply include the .swig module file in your package directory along with the relevant c++ code files and run “go build” or “go install”
1
2
3
cd /project/src/
SWIG -go -c++ simplelib.swig
Common optional parameters you may need to use:
The above SWIG command should generate 3 new files in your project directory. Your project directory should now look something like the following:
1
2
3
4
5
6
simpleclass.h
simpleclass.cpp
simplelib.swig
simplelib.go
simplelib.cxx
simplelib_gc.c
Now we need to include these 3 new files in our projects. Simplelib.cxx contains the C++ wrapper code allowing your C++ project to interop with CGO. simplelib_gc.c contains the C code designed to be called from CGO. simplelib.go contains the GO code stubs for the resulting GO package, it uses cgo to call into the simplelib_gc.c interfaces.
Add the simplelib.cxx file to the C++ project and build with the projects C++ compiler (I have only tested this process with GCC). Simply add it to your makefile or build script.
simplelib_gc.c and simplelib.go need to be included in the go package using the following 5/6/8c and 5/6/8g commands.
1
2
3
go tool 6c -I <Go Installation Path here>/pkg/linux_amd64/ -D _64BIT simplelib_gc.c
go tool 6g simplelib.go
go tool pack grc simplelib.a simplelib.6 simplelib_gc.6
The last step is installation: first install your compiled C++ shared library, then run go install on the package created in the last step.
1
2
cd /go/src/simplelib/
go install
If the installation was successful you should see simplelib.a file in /go/pkg/
That’s it! you should now be able to import “simplelib” in your go projects and call the wrapped C++ code.
To recap the steps required are:
And here is an example makefile:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
CC=g++
ifeq ($(DEBUG),yes)
CXXFLAGS=-Wall -g
LDFLAGS=-Wall -g
else
CXXFLAGS=-Wall
LDFLAGS=-Wall
endif
INCPATH=inc
SRCPATH=src
OBJPATH=obj
LIBPATH=lib
BINPATH=bin
OBJS=$(OBJPATH)/simpleclass.o $(OBJPATH)/simplelib_wrap.o
OUT=$(LIBPATH)/libSimpleLib.so
INCLUDES=-I ./$(INCPATH)
#Set this to your go installation directory
EXE=$$HOME/dev/goinstallation/go/bin/
export PATH := bin:$(PATH)
default: $(OUT)
$(OUT): $(OBJS)
$(CC) $(LDFLAGS) -shared -o $@ $^
obj/simplelib_wrap.o: simplelib_wrap.cxx inc/simpleclass.h
$(CC) $(CXXFLAGS) $(INCLUDES) -fpic -c $< -o $@
obj/simpleclass.o: src/simpleclass.cpp inc/simpleclass.h
$(CC) $(CXXFLAGS) $(INCLUDES) -fpic -c $< -o $@
simplelib_wrap.cxx:
swig -go -c++ -intgosize 64 -soname libSimpleLib.so simplelib.swig
.PHONY: clean cleanall
clean:
rm -f $(OBJPATH)/.o
cleanall: clean
rm -f $(OUT)
rm -f .6
rm -f .a
rm -f .so
rm -f .cxx
rm -f .c
build:
@echo "Building bindings..."
$(EXE)go tool 6c -I $$HOME/dev/goinstallation/go/pkg/linux_amd64/ -D _64BIT simplelib_gc.c
$(EXE)go tool 6g simplelib.go
$(EXE)go tool pack grc simplelib.a simplelib.6 simplelib_gc.6
install:
@echo "Installing go package..."
#Rename swig file so go install command does not try to reprocess it
mv simplelib.swig simplelib.notswig
export GOPATH=$$HOME/dev/go/; </span>
$(EXE)go install
mv simplelib.notswig simplelib.swig
@echo "Installing go shared lib..."
sudo cp -f lib/libSimpleLib.so /usr/local/lib/
sudo ldconfig
Get example project on github: https://github.com/zacg/simplelib
Feel free to leave your comments below.
]]>