text:
namespace moveit_msgs
{

  class PlaceGoal : public ros::Msg
  {
    public:
      typedef const char* _group_name_type;
      _group_name_type group_name;
      typedef const char* _attached_object_name_type;
      _attached_object_name_type attached_object_name;
      uint32_t place_locations_length;
      typedef moveit_msgs::PlaceLocation _place_locations_type;
      _place_locations_type st_place_locations;
      _place_locations_type * place_locations;
      typedef bool _place_eef_type;
      _place_eef_type place_eef;
      typedef const char* _support_surface_name_type;
      _support_surface_name_type support_surface_name;
      typedef bool _allow_gripper_support_collision_type;
      _allow_gripper_support_collision_type allow_gripper_support_collision;
      typedef moveit_msgs::Constraints _path_constraints_type;
      _path_constraints_type path_constraints;
      typedef const char* _planner_id_type;
      _planner_id_type planner_id;
      uint32_t allowed_touch_objects_length;
      typedef char* _allowed_touch_objects_type;
      _allowed_touch_objects_type st_allowed_touch_objects;
      _allowed_touch_objects_type * allowed_touch_objects;
      typedef float _allowed_planning_time_type;
      _allowed_planning_time_type allowed_planning_time;
      typedef moveit_msgs::PlanningOptions _planning_options_type;
      _planning_options_type planning_options;

    PlaceGoal():
      group_name(""),
      attached_object_name(""),
      place_locations_length(0), place_locations(NULL),
      place_eef(0),
      support_surface_name(""),
      allow_gripper_support_collision(0),
      path_constraints(),
      planner_id(""),
      allowed_touch_objects_length(0), allowed_touch_objects(NULL),
      allowed_planning_time(0),
      planning_options()
    {
    }

    virtual int serialize(unsigned char *outbuffer) const
    {
      int offset = 0;
      uint32_t length_group_name = strlen(this->group_name);
      varToArr(outbuffer + offset, length_group_name);
      offset += 4;
      memcpy(outbuffer + offset, this->group_name, length_group_name);
      offset += length_group_name;
      uint32_t length_attached_object_name = strlen(this->attached_object_name);
      varToArr(outbuffer + offset, length_attached_object_name);
      offset += 4;
      memcpy(outbuffer + offset, this->attached_object_name, length_attached_object_name);
      offset += length_attached_object_name;
      *(outbuffer + offset + 0) = (this->place_locations_length >> (8 * 0)) & 0xFF;
      *(outbuffer + offset + 1) = (this->place_locations_length >> (8 * 1)) & 0xFF;
      *(outbuffer + offset + 2) = (this->place_locations_length >> (8 * 2)) & 0xFF;
      *(outbuffer + offset + 3) = (this->place_locations_length >> (8 * 3)) & 0xFF;
      offset += sizeof(this->place_locations_length);
      for( uint32_t i = 0; i < place_locations_length; i++){
      offset += this->place_locations[i].serialize(outbuffer + offset);
      }
      union {
        bool real;
        uint8_t base;
      } u_place_eef;
      u_place_eef.real = this->place_eef;
      *(outbuffer + offset + 0) = (u_place_eef.base >> (8 * 0)) & 0xFF;
      offset += sizeof(this->place_eef);
      uint32_t length_support_surface_name = strlen(this->support_surface_name);
      varToArr(outbuffer + offset, length_support_surface_name);
      offset += 4;
      memcpy(outbuffer + offset, this->support_surface_name, length_support_surface_name);
      offset += length_support_surface_name;
      union {
        bool real;
        uint8_t base;
      } u_allow_gripper_support_collision;
      u_allow_gripper_support_collision.real = this->allow_gripper_support_collision;
      *(outbuffer + offset + 0) = (u_allow_gripper_support_collision.base >> (8 * 0)) & 0xFF;
      offset += sizeof(this->allow_gripper_support_collision);
      offset += this->path_constraints.serialize(outbuffer + offset);
      uint32_t length_planner_id = strlen(this->planner_id);
      varToArr(outbuffer + offset, length_planner_id);
      offset += 4;
      memcpy(outbuffer + offset, this->planner_id, length_planner_id);
      offset += length_planner_id;
      *(outbuffer + offset + 0) = (this->allowed_touch_objects_length >> (8 * 0)) & 0xFF;
      *(outbuffer + offset + 1) = (this->allowed_touch_objects_length >> (8 * 1)) & 0xFF;
      *(outbuffer + offset + 2) = (this->allowed_touch_objects_length >> (8 * 2)) & 0xFF;
      *(outbuffer + offset + 3) = (this->allowed_touch_objects_length >> (8 * 3)) & 0xFF;
      offset += sizeof(this->allowed_touch_objects_length);
      for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
      uint32_t length_allowed_touch_objectsi = strlen(this->allowed_touch_objects[i]);
      varToArr(outbuffer + offset, length_allowed_touch_objectsi);
      offset += 4;
      memcpy(outbuffer + offset, this->allowed_touch_objects[i], length_allowed_touch_objectsi);
      offset += length_allowed_touch_objectsi;
      }
      offset += serializeAvrFloat64(outbuffer + offset, this->allowed_planning_time);
      offset += this->planning_options.serialize(outbuffer + offset);
      return offset;
    }

    virtual int deserialize(unsigned char *inbuffer)
    {
      int offset = 0;
      uint32_t length_group_name;
      arrToVar(length_group_name, (inbuffer + offset));
      offset += 4;
      for(unsigned int k= offset; k< offset+length_group_name; ++k){
          inbuffer[k-1]=inbuffer[k];
      }
      inbuffer[offset+length_group_name-1]=0;
      this->group_name = (char *)(inbuffer + offset-1);
      offset += length_group_name;
      uint32_t length_attached_object_name;
      arrToVar(length_attached_object_name, (inbuffer + offset));
      offset += 4;
      for(unsigned int k= offset; k< offset+length_attached_object_name; ++k){
          inbuffer[k-1]=inbuffer[k];
      }
      inbuffer[offset+length_attached_object_name-1]=0;
      this->attached_object_name = (char *)(inbuffer + offset-1);
      offset += length_attached_object_name;
      uint32_t place_locations_lengthT = ((uint32_t) (*(inbuffer + offset)));
      place_locations_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
      place_locations_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
      place_locations_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
      offset += sizeof(this->place_locations_length);
      if(place_locations_lengthT > place_locations_length)
        this->place_locations = (moveit_msgs::PlaceLocation*)realloc(this->place_locations, place_locations_lengthT * sizeof(moveit_msgs::PlaceLocation));
      place_locations_length = place_locations_lengthT;
      for( uint32_t i = 0; i < place_locations_length; i++){
      offset += this->st_place_locations.deserialize(inbuffer + offset);
        memcpy( &(this->place_locations[i]), &(this->st_place_locations), sizeof(moveit_msgs::PlaceLocation));
      }
      union {
        bool real;
        uint8_t base;
      } u_place_eef;
      u_place_eef.base = 0;
      u_place_eef.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
      this->place_eef = u_place_eef.real;
      offset += sizeof(this->place_eef);
      uint32_t length_support_surface_name;
      arrToVar(length_support_surface_name, (inbuffer + offset));
      offset += 4;
      for(unsigned int k= offset; k< offset+length_support_surface_name; ++k){
          inbuffer[k-1]=inbuffer[k];
      }
      inbuffer[offset+length_support_surface_name-1]=0;
      this->support_surface_name = (char *)(inbuffer + offset-1);
      offset += length_support_surface_name;
      union {
        bool real;
        uint8_t base;
      } u_allow_gripper_support_collision;
      u_allow_gripper_support_collision.base = 0;
      u_allow_gripper_support_collision.base |= ((uint8_t) (*(inbuffer + offset + 0))) << (8 * 0);
      this->allow_gripper_support_collision = u_allow_gripper_support_collision.real;
      offset += sizeof(this->allow_gripper_support_collision);
      offset += this->path_constraints.deserialize(inbuffer + offset);
      uint32_t length_planner_id;
      arrToVar(length_planner_id, (inbuffer + offset));
      offset += 4;
      for(unsigned int k= offset; k< offset+length_planner_id; ++k){
          inbuffer[k-1]=inbuffer[k];
      }
      inbuffer[offset+length_planner_id-1]=0;
      this->planner_id = (char *)(inbuffer + offset-1);
      offset += length_planner_id;
      uint32_t allowed_touch_objects_lengthT = ((uint32_t) (*(inbuffer + offset)));
      allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
      allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
      allowed_touch_objects_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
      offset += sizeof(this->allowed_touch_objects_length);
      if(allowed_touch_objects_lengthT > allowed_touch_objects_length)
        this->allowed_touch_objects = (char**)realloc(this->allowed_touch_objects, allowed_touch_objects_lengthT * sizeof(char*));
      allowed_touch_objects_length = allowed_touch_objects_lengthT;
      for( uint32_t i = 0; i < allowed_touch_objects_length; i++){
      uint32_t length_st_allowed_touch_objects;
      arrToVar(length_st_allowed_touch_objects, (inbuffer + offset));
      offset += 4;
      for(unsigned int k= offset; k< offset+length_st_allowed_touch_objects; ++k){
          inbuffer[k-1]=inbuffer[k];
      }
      inbuffer[offset+length_st_allowed_touch_objects-1]=0;
      this->st_allowed_touch_objects = (char *)(inbuffer + offset-1);
      offset += length_st_allowed_touch_objects;
        memcpy( &(this->allowed_touch_objects[i]), &(this->st_allowed_touch_objects), sizeof(char*));
      }
      offset += deserializeAvrFloat64(inbuffer + offset, &(this->allowed_planning_time));
      offset += this->planning_options.deserialize(inbuffer + offset);
     return offset;
    }

    const char * getType(){ return "moveit_msgs/PlaceGoal"; };
    const char * getMD5(){ return "e3f3e956e536ccd313fd8f23023f0a94"; };

  };

}
#endif


text:
#include <memory>
#include "../assert.h"

namespace cpp {

/// Idea from http://accu.org/index.php/journals/2085
template<typename AbstractClass, class Tag = void>
class mono_interface
{
public:
  explicit mono_interface(std::unique_ptr<AbstractClass> new_instance)
  {
    set(std::move(new_instance));
  }

  mono_interface()
  {
    cpp_assert(instance_ != nullptr);
  }

  AbstractClass* operator->() {
  	return pointer();
  }

  const AbstractClass* operator->() const {
  	return pointer();
  }

  AbstractClass& operator*() {
  	return *instance_;
  }

  const AbstractClass& operator*() const {
  	return *instance_;
  }

  AbstractClass* operator&() {
  	return pointer();
  }

  const AbstractClass* operator&() const {
  	return pointer();
  }

  static AbstractClass& instance() {
  	return *instance_;
  }

  static AbstractClass& get() {
  	return *instance_;
  }

  static AbstractClass* pointer() {
  	return instance_.get();
  }

  static void set(std::unique_ptr<AbstractClass> new_instance) {
    cpp_assert(new_instance != nullptr);
    cpp_assert(instance_ == nullptr);

    instance_ = std::move(new_instance);
  }

private:
  static std::unique_ptr<AbstractClass> instance_; // TODO: make atomic
};

template<typename AbstractClass, typename Tag>
std::unique_ptr<AbstractClass> mono_interface<AbstractClass, Tag>::instance_;

}

redpajama_set_name: RedPajamaGithub


text:
/// Copyright (c) 2012 Ecma International.  All rights reserved.
/**
 * @path ch15/15.4/15.4.4/15.4.4.17/15.4.4.17-7-b-16.js
 * @description Array.prototype.some - decreasing length of array does not delete non-configurable properties
 */

function testcase() {
        function callbackfn(val, idx, obj) {
            if (idx === 2 && val === "unconfigurable") {
                return true;
            } else {
                return false;
            }
        }

        var arr = [0, 1, 2];

        Object.defineProperty(arr, "2", {
            get: function () {
                return "unconfigurable";
            },
            configurable: false
        });

        Object.defineProperty(arr, "1", {
            get: function () {
                arr.length = 2;
                return 1;
            },
            configurable: true
        });

        return arr.some(callbackfn);
    }
runTestCase(testcase);


text:
using System;
using System.Diagnostics;
using System.Windows;
using System.Windows.Input;

namespace RzWpf
{
    public static class Navigation
    {
        public delegate void DialogDelegate( IInlineDialog dialog, Action callback );

        public static Action<object> NavigateAction { get; set; }
        public static Action CloseWindowAction { get; set; }
        public static Action BackAction { get; set; }
        public static DialogDelegate ShowDialogAction { get; set; }

        public static event Action Closing;

        public static void GoTo( object targetPage )
        {
            Application.Current.Dispatcher.CheckedInvoke( () =>
            {
                if( null != NavigateAction ) NavigateAction( targetPage );
            } );
        }

        public static void RaiseClosing()
        {
            if( Closing != null ) Closing();
        }

        public static void Close()
        {
            Application.Current.Dispatcher.CheckedInvoke( () =>
            {
                if( Closing != null ) Closing();
                if( null != CloseWindowAction ) CloseWindowAction();
            } );
        }

        public static void GoBack()
        {
            Application.Current.Dispatcher.CheckedInvoke( () =>
            {
                if( null != BackAction ) BackAction();
            } );
        }

        public static void ShowDialog( IInlineDialog dialog, Action callback = null )
        {
            Debug.Assert( null != dialog );

            Application.Current.Dispatcher.CheckedInvoke( () =>
            {
                if( null != ShowDialogAction ) ShowDialogAction( dialog, callback );
            } );

            CommandManager.InvalidateRequerySuggested();
        }
    }
}


text:
@implementation Animator

- (NSTimeInterval)transitionDuration:(nullable id <UIViewControllerContextTransitioning>)transitionContext{
    return 0.25;
}
- (void)animateTransition:(id <UIViewControllerContextTransitioning>)transitionContext{
    UIView *containerView =  transitionContext.containerView;
//    containerView.backgroundColor = [UIColor whiteColor];
    UIViewController *fromVc =  [transitionContext viewControllerForKey:UITransitionContextFromViewControllerKey];

    UIViewController *toVc = [transitionContext viewControllerForKey:UITransitionContextToViewControllerKey];

    BOOL isPush =fromVc.navigationController.topViewController == toVc;
    if (isPush) {
        [fromVc.view removeFromSuperview];
        [containerView addSubview:toVc.view];

        toVc.view.height = 0;

        [UIView animateWithDuration:0.5 animations:^{
            toVc.view.height = [UIScreen mainScreen].bounds.size.height;
        }];
    }else{
        [toVc.view removeFromSuperview];
        [containerView addSubview:fromVc.view];

        fromVc.view.height = 0;

        [UIView animateWithDuration:0.5 animations:^{
            fromVc.view.height = [UIScreen mainScreen].bounds.size.height;
        }];
    }

    // This must be called whenever a transition completes (or is cancelled.)
    [transitionContext completeTransition:YES];

}

@end


text: sudo docker stop techonmap-docker


text:
package sun.nio.ch;

import java.io.*;

/**
 * Allows different platforms to call different native methods
 * for read and write operations.
 */

class FileDispatcher extends NativeDispatcher
{

    static {
        Util.load();
    }

    int read(FileDescriptor fd, long address, int len)
        throws IOException
    {
        return read0(fd, address, len);
    }

    int pread(FileDescriptor fd, long address, int len,
                             long position, Object lock) throws IOException
    {
        synchronized(lock) {
            return pread0(fd, address, len, position);
        }
    }

    long readv(FileDescriptor fd, long address, int len) throws IOException {
        return readv0(fd, address, len);
    }

    int write(FileDescriptor fd, long address, int len) throws IOException {
        return write0(fd, address, len);
    }

    int pwrite(FileDescriptor fd, long address, int len,
                             long position, Object lock) throws IOException
    {
        synchronized(lock) {
            return pwrite0(fd, address, len, position);
        }
    }

    long writev(FileDescriptor fd, long address, int len) throws IOException {
        return writev0(fd, address, len);
    }

    void close(FileDescriptor fd) throws IOException {
        close0(fd);
    }

    //-- Native methods

    static native int read0(FileDescriptor fd, long address, int len)
        throws IOException;

    static native int pread0(FileDescriptor fd, long address, int len,
                             long position) throws IOException;

    static native long readv0(FileDescriptor fd, long address, int len)
        throws IOException;

    static native int write0(FileDescriptor fd, long address, int len)
        throws IOException;

    static native int pwrite0(FileDescriptor fd, long address, int len,
                             long position) throws IOException;

    static native long writev0(FileDescriptor fd, long address, int len)
        throws IOException;

    static native void close0(FileDescriptor fd) throws IOException;

    static native void closeByHandle(long fd) throws IOException;

}


text:
#include <linux/pci.h>
#include <linux/export.h>
#include <asm/pci-bridge.h>
#include <asm/ppc-pci.h>
#include <asm/firmware.h>
#include <asm/eeh.h>

#include "pseries.h"

static struct pci_bus *
find_bus_among_children(struct pci_bus *bus,
                        struct device_node *dn)
{
	struct pci_bus *child = NULL;
	struct pci_bus *tmp;
	struct device_node *busdn;

	busdn = pci_bus_to_OF_node(bus);
	if (busdn == dn)
		return bus;

	list_for_each_entry(tmp, &bus->children, node) {
		child = find_bus_among_children(tmp, dn);
		if (child)
			break;
	};
	return child;
}

struct pci_bus *
pcibios_find_pci_bus(struct device_node *dn)
{
	struct pci_dn *pdn = dn->data;

	if (!pdn  || !pdn->phb || !pdn->phb->bus)
		return NULL;

	return find_bus_among_children(pdn->phb->bus, dn);
}
EXPORT_SYMBOL_GPL(pcibios_find_pci_bus);

struct pci_controller *init_phb_dynamic(struct device_node *dn)
{
	struct pci_controller *phb;

	pr_debug("PCI: Initializing new hotplug PHB %s\n", dn->full_name);

	phb = pcibios_alloc_controller(dn);
	if (!phb)
		return NULL;
	rtas_setup_phb(phb);
	pci_process_bridge_OF_ranges(phb, dn, 0);
	phb->controller_ops = pseries_pci_controller_ops;

	pci_devs_phb_init_dynamic(phb);

	/* Create EEH devices for the PHB */
	eeh_dev_phb_init_dynamic(phb);

	if (dn->child)
		eeh_add_device_tree_early(PCI_DN(dn));

	pcibios_scan_phb(phb);
	pcibios_finish_adding_to_bus(phb->bus);

	return phb;
}
EXPORT_SYMBOL_GPL(init_phb_dynamic);

/* RPA-specific bits for removing PHBs */
int remove_phb_dynamic(struct pci_controller *phb)
{
	struct pci_bus *b = phb->bus;
	struct resource *res;
	int rc, i;

	pr_debug("PCI: Removing PHB %04x:%02x...\n",
		 pci_domain_nr(b), b->number);

	/* We cannot to remove a root bus that has children */
	if (!(list_empty(&b->children) && list_empty(&b->devices)))
		return -EBUSY;

	/* We -know- there aren't any child devices anymore at this stage
	 * and thus, we can safely unmap the IO space as it's not in use
	 */
	res = &phb->io_resource;
	if (res->flags & IORESOURCE_IO) {
		rc = pcibios_unmap_io_space(b);
		if (rc) {
			printk(KERN_ERR "%s: failed to unmap IO on bus %s\n",
			       __func__, b->name);
			return 1;
		}
	}

	/* Remove the PCI bus and unregister the bridge device from sysfs */
	phb->bus = NULL;
	pci_remove_bus(b);
	device_unregister(b->bridge);

	/* Now release the IO resource */
	if (res->flags & IORESOURCE_IO)
		release_resource(res);

	/* Release memory resources */
	for (i = 0; i < 3; ++i) {
		res = &phb->mem_resources[i];
		if (!(res->flags & IORESOURCE_MEM))
			continue;
		release_resource(res);
	}

	/* Free pci_controller data structure */
	pcibios_free_controller(phb);

	return 0;
}
EXPORT_SYMBOL_GPL(remove_phb_dynamic);


text:
<?xml version="1.0" encoding="utf-8"?>
<project>
	<window vsync="false" />
</project>


text:
use shared::minwindef::DWORD;
use shared::wtypes::PROPERTYKEY;
use um::propidl::{PROPVARIANT, REFPROPVARIANT};
use um::propkeydef::REFPROPERTYKEY;
use um::unknwnbase::{IUnknown, IUnknownVtbl};
use um::winnt::HRESULT;

pub type IPropertyDescriptionList = IUnknown; // TODO

RIDL!(#[uuid(0x886d8eeb, 0x8cf2, 0x4446, 0x8d, 0x02, 0xcd, 0xba, 0x1d, 0xbd, 0xcf, 0x99)]
interface IPropertyStore(IPropertyStoreVtbl): IUnknown(IUnknownVtbl) {
    fn GetCount(
        cProps: *mut DWORD,
    ) -> HRESULT,
    fn GetAt(
        iProp: DWORD,
        pkey: *mut PROPERTYKEY,
    ) -> HRESULT,
    fn GetValue(
        key: REFPROPERTYKEY,
        pv: *mut PROPVARIANT,
    ) -> HRESULT,
    fn SetValue(
        key: REFPROPERTYKEY,
        propvar: REFPROPVARIANT,
    ) -> HRESULT,
    fn Commit() -> HRESULT,
}
);


text:
import Vue from 'vue'
import Router from 'vue-router'
import Home from 'components/Home'
import newslist from 'components/news/newsList'
import newsshow from 'components/news/newsshow'
import photolist from 'components/photos/photolist'
import imgshow from 'components/photos/imgshow'

Vue.use(Router)

export default new Router({
  linkActiveClass:'mui-active',
  routes: [
    {
      path: '/',
      name: 'Home',
      component: Home
    },
    {
      path: '/Home',
      name: 'Home2',
      component: Home
    },
    {
      path: '/newsList',
      name: 'newsList',
      component: newslist
    },
    {
      path: '/news/newsshow/:newsid',
      name: 'newsshow',
      component: newsshow
    },
    {
      path: '/photolist',
      name: 'photolist',
      component: photolist
    },
    {
      path: '/imgshow/:imgid',
      name: 'imgshow',
      component: imgshow
    }

  ]
})


text:
package edu.wustl.cab2bwebapp.action;

import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.globus.gsi.GlobusCredential;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;

import edu.common.dynamicextensions.domaininterface.AttributeInterface;
import edu.wustl.cab2b.common.authentication.Authenticator;
import edu.wustl.cab2b.common.authentication.exception.AuthenticationException;
import edu.wustl.cab2b.common.modelgroup.ModelGroupInterface;
import edu.wustl.cab2b.common.queryengine.ICab2bQuery;
import edu.wustl.cab2b.common.user.ServiceURLInterface;
import edu.wustl.cab2b.common.user.User;
import edu.wustl.cab2b.common.user.UserInterface;
import edu.wustl.cab2b.server.modelgroup.ModelGroupOperations;
import edu.wustl.cab2b.server.user.UserOperations;
import edu.wustl.cab2bwebapp.bizlogic.ApplicationBizLogic;
import edu.wustl.cab2bwebapp.bizlogic.SavedQueryBizLogic;
import edu.wustl.cab2bwebapp.bizlogic.executequery.QueryBizLogic;
import edu.wustl.cab2bwebapp.bizlogic.executequery.TransformedResultObjectWithContactInfo;
import edu.wustl.cab2bwebapp.constants.Constants;

/**
 * JSON REST API for conducting simple keyword searches and returning metadata
 * in caB2B.
 *
 * @author Konrad Rokicki
 */
public class JSONRESTService extends HttpServlet {

    private static Logger log = Logger.getLogger(JSONRESTService.class);

    private static final String GLOBUS_USERNAME = "gssuser";
    private static final String GLOBUS_PASSWORD = "GSS#pswd12";

    /**
     * Handles Get requests.
     */
    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        PrintWriter pw = new PrintWriter(response.getOutputStream());
        response.setContentType("application/json");

        try {

            GlobusCredential globusCredential = null;
            try {
                globusCredential = new Authenticator(GLOBUS_USERNAME).validateUser(GLOBUS_PASSWORD);
            } catch (AuthenticationException e) {
                log.error("Could not login to Globus",e);
                // Log error but proceed with null credentials so that users
                // can access non-secure data at least
            }

            // The user must be in the database because QueryStatus will be linked to it later
            UserOperations userOperations = new UserOperations();
            UserInterface globusUser = userOperations.getUserByName(globusCredential.getIdentity());
            if (globusUser == null) {
                log.info("Adding user: "+globusCredential.getIdentity());
                globusUser = userOperations.insertUser(new User(globusCredential.getIdentity(), null, false));
            }

            String result = "";
            String path = request.getPathInfo();
            if (path == null) {
                result = getJSONUsage(globusCredential);
            }
            else {
                String[] pathList = path.split("/");
                if (pathList.length < 2) {
                    result = getJSONUsage(globusCredential);
                }
                else {
                    String noun = pathList[1];
                    if ("search".equals(noun)) {
                        result = handleSearch(request, globusCredential);
                    }
                    else if ("services".equals(noun)) {
                        result = handleService(request, globusCredential);
                    }
                    else {
                        result = getJSONError("UsageError", "Unrecognized noun '"+noun+"'");
                    }
                }
            }

            pw.print(result);
        }
        catch (Exception e) {
            log.error("Error",e);
            pw.println(getJSONError(e.getClass().getName(), e.getMessage()));
        }
        finally {
            pw.close();
        }
    }

    /**
     * Handles Post requests by calling doGet.
     */
    @Override
    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        doGet(request, response);
    }

    /**
     * Unload servlet.
     */
    @Override
    public void destroy() {
        super.destroy();
    }

    /**
     * Handles REST requests and returns JSON.
     */
    private String handleService(HttpServletRequest request,
            GlobusCredential globusCredential) throws Exception {

        String[] modelGroupNames = getModelGroups(globusCredential);

        UserInterface user = new UserOperations().getUserByName(Constants.ANONYMOUS);

        UserInterface admin = new UserOperations().getAdmin();
        Set<ServiceURLInterface> adminServices = new HashSet(admin.getServiceURLCollection());

        JSONObject json = new JSONObject();

        for (String modelGroupName : modelGroupNames) {

            JSONArray jsonArray = new JSONArray();
            json.put(modelGroupName, jsonArray);

            List<ServiceURLInterface> urls =
                new ApplicationBizLogic().getApplicationInstances(user, modelGroupName);

            for(ServiceURLInterface url : urls) {
                JSONObject urlJson = new JSONObject();
                urlJson.put("url",url.getUrlLocation());
                if (adminServices.contains(url)) {
                    urlJson.put("searchDefault","true");
                }
                jsonArray.put(urlJson);
            }
        }

        return json.toString();
    }

    /**
     * Handles REST requests and returns JSON.
     */
    private String handleSearch(HttpServletRequest request,
            GlobusCredential globusCredential) throws Exception {

        final String searchString = request.getParameter("searchString");
        final String modelGroup = request.getParameter("modelGroup");

        final Set<String> serviceUrlSet = new HashSet<String>();
        for(String url : request.getParameterValues("serviceUrl")) {
            serviceUrlSet.add(url.trim());
        }

        SavedQueryBizLogic savedQueryBizLogic = new SavedQueryBizLogic();

        if (searchString == null || "".equals(searchString)) {
            return getJSONUsage(globusCredential);
        }

        // Which model group are we querying?

        String[] modelGroupNames = null;
        if (modelGroup == null || "".equals(modelGroup)) {
            if (serviceUrlSet.isEmpty()) {
                // User must specify either serviceUrl or modelGroup
                return getJSONUsage(globusCredential);
            }
            // Use all model groups for now. We can infer a single one later
            // based on the serviceUrls.
            modelGroupNames = getModelGroups(globusCredential);
        }
        else {
            if (!verifyModelGroup(modelGroup, globusCredential)) {
                return getJSONError("InvalidDataType",
                    "'"+modelGroup+"' is not a valid model group");
            }
            // User specified a single, valid model group
            modelGroupNames = new String[1];
            modelGroupNames[0] = modelGroup;
        }

        // Infer a single model group, if the user did not specify one

        String inferredModelGroup = null;

        // Create a temporary user

        UserInterface user = new UserOperations().getUserByName(Constants.ANONYMOUS);

        // Configure the service urls that we will query

        Collection<ServiceURLInterface> userUrls = user.getServiceURLCollection();
        for (String modelGroupName : modelGroupNames) {

            List<ServiceURLInterface> urls =
                new ApplicationBizLogic().getApplicationInstances(user, modelGroupName);

            if (!serviceUrlSet.isEmpty()) {
                // The user specified services to be queried
                for (ServiceURLInterface url : urls) {
                    if (serviceUrlSet.contains(url.getUrlLocation())) {
                        // Found a specified service
                        userUrls.add(url);
                        inferredModelGroup = modelGroupName;
                    }
                }
            }
            else {
                // Just query all the services in the model group
                userUrls.addAll(urls);
            }
        }

        // Did we have to infer a model group?

        if (inferredModelGroup != null) {
            modelGroupNames = new String[1];
            modelGroupNames[0] = inferredModelGroup;
        }

        if (userUrls.isEmpty()) {
            return getJSONError("UnknownServiceURLs",
                "No known caGrid service URLs were provided");
        }

        Long queryId =
                savedQueryBizLogic.getKeywordQueryId(modelGroupNames[0]);
        ICab2bQuery query = savedQueryBizLogic.getQueryById(queryId);

        log.info("REST Search - initializing");
        log.info("REST Search - search string: "+searchString);
        log.info("REST Search - model group: "+modelGroupNames[0]);
        for (ServiceURLInterface url : userUrls) {
            log.info("REST Search - url: "+url.getUrlLocation());
        }

        QueryBizLogic queryBizLogic = new QueryBizLogic(query, null,
            searchString, user, globusCredential, modelGroupNames);

        log.info("REST Search - executing");
        Thread.sleep(200);
        while (!queryBizLogic.isProcessingFinished()) {
            Thread.sleep(100);
        }
        log.info("REST Search - complete");

        // Construct result object

        JSONObject json = getSearchResultsJSON(queryBizLogic, userUrls);
        json.put("modelGroupName",modelGroupNames[0]);

        return json.toString();
    }

    /**
     * Create and return a JSON object with the search results.
     * @param searchResults
     * @return
     * @throws JSONException
     */
    private JSONObject getSearchResultsJSON(QueryBizLogic queryBizLogic,
            Collection<ServiceURLInterface> userUrls) throws Exception {

        final Map<ICab2bQuery, TransformedResultObjectWithContactInfo> searchResults =
            queryBizLogic.getSearchResults();

        final Collection<ServiceURLInterface> failedURLS =
            queryBizLogic.getFailedServiceUrls();

        // Which URLs failed?

        Set<String> failedUrlSet = new HashSet<String>();
        for(ServiceURLInterface failedURL : failedURLS) {
            failedUrlSet.add(failedURL.getUrlLocation());
        }

        // Create JSON result objects

        JSONObject json = new JSONObject();

        JSONObject resultMapJson = new JSONObject();
        json.put("results",resultMapJson);

        for (ICab2bQuery queryObj : searchResults.keySet()) {

            JSONObject queryResultsJson = new JSONObject();
            resultMapJson.put(queryObj.getName(),queryResultsJson);

            TransformedResultObjectWithContactInfo res = searchResults.get(queryObj);

            for(String url : res.getAllUrls()) {

                JSONArray resultsJson = new JSONArray();

                // Create a list of results for this service

                for(Map<AttributeInterface, Object> result : res.getResultForUrl(url)) {

                    JSONObject resultJson = new JSONObject();
                    resultsJson.put(resultJson);

                    for(AttributeInterface a : result.keySet()) {
                        String value = String.valueOf(result.get(a));
                        String title = edu.wustl.cab2b.common.util.Utility.getFormattedString(a.getName());
                        resultJson.put(title, value);
                    }
                }

                queryResultsJson.put(url,resultsJson);
            }
        }

        JSONArray failedUrlsJson = new JSONArray();
        json.put("failedUrls",failedUrlsJson);

        for(String url : failedUrlSet) {
            failedUrlsJson.put(url);
        }

        return json;
    }

    /**
     * Ensure the given model group exists and the user has access to it.
     * @param modelGroup
     * @param globusCredential
     * @return
     */
    private boolean verifyModelGroup(String modelGroup, GlobusCredential globusCredential) {

        String[] allModelGroupNames = getModelGroups(globusCredential);
        boolean found = false;
        for(String modelGroupName : allModelGroupNames) {
            if (modelGroupName.equals(modelGroup)) {
                found = true;
                break;
            }
        }
        return found;
    }

    /**
     * Returns a JSON string with the given error message.
     * @return JSON-formatted String
     */
    private String getJSONError(String exception, String message) {
        return "{\"error\":\""+exception+"\",\"message\":\""+message+"\"}";
    }

    /**
     * Returns a JSON string with usage instructions, or an error if a problem
     * occurs.
     * @return JSON-formatted String
     */
    private String getJSONUsage(GlobusCredential globusCredential) {

        try {

            String[] allModelGroupNames = getModelGroups(globusCredential);
            StringBuffer modelGroupUsage = new StringBuffer();
            for(String modelGroupName : allModelGroupNames) {
                if (modelGroupUsage.length()>0) modelGroupUsage.append("|");
                modelGroupUsage.append(modelGroupName);
            }

            JSONArray jsonArray = new JSONArray();
            jsonArray.put("/api/services");
            jsonArray.put("/api/search?searchString={1}&modelGroup={2["+modelGroupUsage+"]}&serviceUrl={3}");
            JSONObject jsonObj = new JSONObject();
            jsonObj.put("supported_paths", jsonArray);

            return jsonObj.toString();
        }
        catch (JSONException x) {
            return getJSONError("JSONError", "Error printing JSON usage");
        }
    }

    /**
     * Get the model groups available with the given credentials.
     * @param globusCredential
     * @return
     */
    public String[] getModelGroups(GlobusCredential globusCredential) {

        ModelGroupOperations modelGroupOperations = new ModelGroupOperations();
        List<ModelGroupInterface> modelGroups = new ArrayList<ModelGroupInterface>();
        if (globusCredential == null) {
            modelGroups.addAll(modelGroupOperations.getAllNonSecuredModelGroups());
        } else {
            modelGroups.addAll(modelGroupOperations.getAllModelGroups());
        }
        String[] modelGroupNames = new String[modelGroups.size()];
        for (int i = 0; i < modelGroups.size(); i++) {
            modelGroupNames[i] = modelGroups.get(i).getModelGroupName();
        }
        return modelGroupNames;
    }

}


text:
@interface FAKIonIcons : FAKIcon

// Generated Code
+ (instancetype)alertIconWithSize:(CGFloat)size;
+ (instancetype)alertCircledIconWithSize:(CGFloat)size;
+ (instancetype)androidAddIconWithSize:(CGFloat)size;
+ (instancetype)androidAddContactIconWithSize:(CGFloat)size;
+ (instancetype)androidAlarmIconWithSize:(CGFloat)size;
+ (instancetype)androidArchiveIconWithSize:(CGFloat)size;
+ (instancetype)androidArrowBackIconWithSize:(CGFloat)size;
+ (instancetype)androidArrowDownLeftIconWithSize:(CGFloat)size;
+ (instancetype)androidArrowDownRightIconWithSize:(CGFloat)size;
+ (instancetype)androidArrowUpLeftIconWithSize:(CGFloat)size;
+ (instancetype)androidArrowUpRightIconWithSize:(CGFloat)size;
+ (instancetype)androidBatteryIconWithSize:(CGFloat)size;
+ (instancetype)androidBookIconWithSize:(CGFloat)size;
+ (instancetype)androidCalendarIconWithSize:(CGFloat)size;
+ (instancetype)androidCallIconWithSize:(CGFloat)size;
+ (instancetype)androidCameraIconWithSize:(CGFloat)size;
+ (instancetype)androidChatIconWithSize:(CGFloat)size;
+ (instancetype)androidCheckmarkIconWithSize:(CGFloat)size;
+ (instancetype)androidClockIconWithSize:(CGFloat)size;
+ (instancetype)androidCloseIconWithSize:(CGFloat)size;
+ (instancetype)androidContactIconWithSize:(CGFloat)size;
+ (instancetype)androidContactsIconWithSize:(CGFloat)size;
+ (instancetype)androidDataIconWithSize:(CGFloat)size;
+ (instancetype)androidDeveloperIconWithSize:(CGFloat)size;
+ (instancetype)androidDisplayIconWithSize:(CGFloat)size;
+ (instancetype)androidDownloadIconWithSize:(CGFloat)size;
+ (instancetype)androidDropdownIconWithSize:(CGFloat)size;
+ (instancetype)androidEarthIconWithSize:(CGFloat)size;
+ (instancetype)androidFolderIconWithSize:(CGFloat)size;
+ (instancetype)androidForumsIconWithSize:(CGFloat)size;
+ (instancetype)androidFriendsIconWithSize:(CGFloat)size;
+ (instancetype)androidHandIconWithSize:(CGFloat)size;
+ (instancetype)androidImageIconWithSize:(CGFloat)size;
+ (instancetype)androidInboxIconWithSize:(CGFloat)size;
+ (instancetype)androidInformationIconWithSize:(CGFloat)size;
+ (instancetype)androidKeypadIconWithSize:(CGFloat)size;
+ (instancetype)androidLightbulbIconWithSize:(CGFloat)size;
+ (instancetype)androidLocateIconWithSize:(CGFloat)size;
+ (instancetype)androidLocationIconWithSize:(CGFloat)size;
+ (instancetype)androidMailIconWithSize:(CGFloat)size;
+ (instancetype)androidMicrophoneIconWithSize:(CGFloat)size;
+ (instancetype)androidMixerIconWithSize:(CGFloat)size;
+ (instancetype)androidMoreIconWithSize:(CGFloat)size;
+ (instancetype)androidNoteIconWithSize:(CGFloat)size;
+ (instancetype)androidPlaystoreIconWithSize:(CGFloat)size;
+ (instancetype)androidPrinterIconWithSize:(CGFloat)size;
+ (instancetype)androidPromotionIconWithSize:(CGFloat)size;
+ (instancetype)androidReminderIconWithSize:(CGFloat)size;
+ (instancetype)androidRemoveIconWithSize:(CGFloat)size;
+ (instancetype)androidSearchIconWithSize:(CGFloat)size;
+ (instancetype)androidSendIconWithSize:(CGFloat)size;
+ (instancetype)androidSettingsIconWithSize:(CGFloat)size;
+ (instancetype)androidShareIconWithSize:(CGFloat)size;
+ (instancetype)androidSocialIconWithSize:(CGFloat)size;
+ (instancetype)androidSocialUserIconWithSize:(CGFloat)size;
+ (instancetype)androidSortIconWithSize:(CGFloat)size;
+ (instancetype)androidStarIconWithSize:(CGFloat)size;
+ (instancetype)androidStopwatchIconWithSize:(CGFloat)size;
+ (instancetype)androidStorageIconWithSize:(CGFloat)size;
+ (instancetype)androidSystemBackIconWithSize:(CGFloat)size;
+ (instancetype)androidSystemHomeIconWithSize:(CGFloat)size;
+ (instancetype)androidSystemWindowsIconWithSize:(CGFloat)size;
+ (instancetype)androidTimerIconWithSize:(CGFloat)size;
+ (instancetype)androidTrashIconWithSize:(CGFloat)size;
+ (instancetype)androidVolumeIconWithSize:(CGFloat)size;
+ (instancetype)androidWifiIconWithSize:(CGFloat)size;
+ (instancetype)archiveIconWithSize:(CGFloat)size;
+ (instancetype)arrowDownAIconWithSize:(CGFloat)size;
+ (instancetype)arrowDownBIconWithSize:(CGFloat)size;
+ (instancetype)arrowDownCIconWithSize:(CGFloat)size;
+ (instancetype)arrowExpandIconWithSize:(CGFloat)size;
+ (instancetype)arrowGraphDownLeftIconWithSize:(CGFloat)size;
+ (instancetype)arrowGraphDownRightIconWithSize:(CGFloat)size;
+ (instancetype)arrowGraphUpLeftIconWithSize:(CGFloat)size;
+ (instancetype)arrowGraphUpRightIconWithSize:(CGFloat)size;
+ (instancetype)arrowLeftAIconWithSize:(CGFloat)size;
+ (instancetype)arrowLeftBIconWithSize:(CGFloat)size;
+ (instancetype)arrowLeftCIconWithSize:(CGFloat)size;
+ (instancetype)arrowMoveIconWithSize:(CGFloat)size;
+ (instancetype)arrowResizeIconWithSize:(CGFloat)size;
+ (instancetype)arrowReturnLeftIconWithSize:(CGFloat)size;
+ (instancetype)arrowReturnRightIconWithSize:(CGFloat)size;
+ (instancetype)arrowRightAIconWithSize:(CGFloat)size;
+ (instancetype)arrowRightBIconWithSize:(CGFloat)size;
+ (instancetype)arrowRightCIconWithSize:(CGFloat)size;
+ (instancetype)arrowShrinkIconWithSize:(CGFloat)size;
+ (instancetype)arrowSwapIconWithSize:(CGFloat)size;
+ (instancetype)arrowUpAIconWithSize:(CGFloat)size;
+ (instancetype)arrowUpBIconWithSize:(CGFloat)size;
+ (instancetype)arrowUpCIconWithSize:(CGFloat)size;
+ (instancetype)atIconWithSize:(CGFloat)size;
+ (instancetype)bagIconWithSize:(CGFloat)size;
+ (instancetype)batteryChargingIconWithSize:(CGFloat)size;
+ (instancetype)batteryEmptyIconWithSize:(CGFloat)size;
+ (instancetype)batteryFullIconWithSize:(CGFloat)size;
+ (instancetype)batteryHalfIconWithSize:(CGFloat)size;
+ (instancetype)batteryLowIconWithSize:(CGFloat)size;
+ (instancetype)beakerIconWithSize:(CGFloat)size;
+ (instancetype)beerIconWithSize:(CGFloat)size;
+ (instancetype)bluetoothIconWithSize:(CGFloat)size;
+ (instancetype)bookmarkIconWithSize:(CGFloat)size;
+ (instancetype)briefcaseIconWithSize:(CGFloat)size;
+ (instancetype)bugIconWithSize:(CGFloat)size;
+ (instancetype)calculatorIconWithSize:(CGFloat)size;
+ (instancetype)calendarIconWithSize:(CGFloat)size;
+ (instancetype)cameraIconWithSize:(CGFloat)size;
+ (instancetype)cardIconWithSize:(CGFloat)size;
+ (instancetype)chatboxIconWithSize:(CGFloat)size;
+ (instancetype)chatboxWorkingIconWithSize:(CGFloat)size;
+ (instancetype)chatboxesIconWithSize:(CGFloat)size;
+ (instancetype)chatbubbleIconWithSize:(CGFloat)size;
+ (instancetype)chatbubbleWorkingIconWithSize:(CGFloat)size;
+ (instancetype)chatbubblesIconWithSize:(CGFloat)size;
+ (instancetype)checkmarkIconWithSize:(CGFloat)size;
+ (instancetype)checkmarkCircledIconWithSize:(CGFloat)size;
+ (instancetype)checkmarkRoundIconWithSize:(CGFloat)size;
+ (instancetype)chevronDownIconWithSize:(CGFloat)size;
+ (instancetype)chevronLeftIconWithSize:(CGFloat)size;
+ (instancetype)chevronRightIconWithSize:(CGFloat)size;
+ (instancetype)chevronUpIconWithSize:(CGFloat)size;
+ (instancetype)clipboardIconWithSize:(CGFloat)size;
+ (instancetype)clockIconWithSize:(CGFloat)size;
+ (instancetype)closeIconWithSize:(CGFloat)size;
+ (instancetype)closeCircledIconWithSize:(CGFloat)size;
+ (instancetype)closeRoundIconWithSize:(CGFloat)size;
+ (instancetype)cloudIconWithSize:(CGFloat)size;
+ (instancetype)codeIconWithSize:(CGFloat)size;
+ (instancetype)codeDownloadIconWithSize:(CGFloat)size;
+ (instancetype)codeWorkingIconWithSize:(CGFloat)size;
+ (instancetype)coffeeIconWithSize:(CGFloat)size;
+ (instancetype)compassIconWithSize:(CGFloat)size;
+ (instancetype)composeIconWithSize:(CGFloat)size;
+ (instancetype)connectionBarsIconWithSize:(CGFloat)size;
+ (instancetype)contrastIconWithSize:(CGFloat)size;
+ (instancetype)discIconWithSize:(CGFloat)size;
+ (instancetype)documentIconWithSize:(CGFloat)size;
+ (instancetype)documentTextIconWithSize:(CGFloat)size;
+ (instancetype)dragIconWithSize:(CGFloat)size;
+ (instancetype)earthIconWithSize:(CGFloat)size;
+ (instancetype)editIconWithSize:(CGFloat)size;
+ (instancetype)eggIconWithSize:(CGFloat)size;
+ (instancetype)ejectIconWithSize:(CGFloat)size;
+ (instancetype)emailIconWithSize:(CGFloat)size;
+ (instancetype)eyeIconWithSize:(CGFloat)size;
+ (instancetype)eyeDisabledIconWithSize:(CGFloat)size;
+ (instancetype)femaleIconWithSize:(CGFloat)size;
+ (instancetype)filingIconWithSize:(CGFloat)size;
+ (instancetype)filmMarkerIconWithSize:(CGFloat)size;
+ (instancetype)flagIconWithSize:(CGFloat)size;
+ (instancetype)flashIconWithSize:(CGFloat)size;
+ (instancetype)flashOffIconWithSize:(CGFloat)size;
+ (instancetype)flaskIconWithSize:(CGFloat)size;
+ (instancetype)folderIconWithSize:(CGFloat)size;
+ (instancetype)forkIconWithSize:(CGFloat)size;
+ (instancetype)forkRepoIconWithSize:(CGFloat)size;
+ (instancetype)forwardIconWithSize:(CGFloat)size;
+ (instancetype)gameControllerAIconWithSize:(CGFloat)size;
+ (instancetype)gameControllerBIconWithSize:(CGFloat)size;
+ (instancetype)gearAIconWithSize:(CGFloat)size;
+ (instancetype)gearBIconWithSize:(CGFloat)size;
+ (instancetype)gridIconWithSize:(CGFloat)size;
+ (instancetype)hammerIconWithSize:(CGFloat)size;
+ (instancetype)headphoneIconWithSize:(CGFloat)size;
+ (instancetype)heartIconWithSize:(CGFloat)size;
+ (instancetype)helpIconWithSize:(CGFloat)size;
+ (instancetype)helpBuoyIconWithSize:(CGFloat)size;
+ (instancetype)helpCircledIconWithSize:(CGFloat)size;
+ (instancetype)homeIconWithSize:(CGFloat)size;
+ (instancetype)icecreamIconWithSize:(CGFloat)size;
+ (instancetype)iconSocialGooglePlusIconWithSize:(CGFloat)size;
+ (instancetype)iconSocialGooglePlusOutlineIconWithSize:(CGFloat)size;
+ (instancetype)imageIconWithSize:(CGFloat)size;
+ (instancetype)imagesIconWithSize:(CGFloat)size;
+ (instancetype)informationIconWithSize:(CGFloat)size;
+ (instancetype)informationCircledIconWithSize:(CGFloat)size;
+ (instancetype)ionicIconWithSize:(CGFloat)size;
+ (instancetype)ios7AlarmIconWithSize:(CGFloat)size;
+ (instancetype)ios7AlarmOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7AlbumsIconWithSize:(CGFloat)size;
+ (instancetype)ios7AlbumsOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7ArrowBackIconWithSize:(CGFloat)size;
+ (instancetype)ios7ArrowDownIconWithSize:(CGFloat)size;
+ (instancetype)ios7ArrowForwardIconWithSize:(CGFloat)size;
+ (instancetype)ios7ArrowLeftIconWithSize:(CGFloat)size;
+ (instancetype)ios7ArrowRightIconWithSize:(CGFloat)size;
+ (instancetype)ios7ArrowThinDownIconWithSize:(CGFloat)size;
+ (instancetype)ios7ArrowThinLeftIconWithSize:(CGFloat)size;
+ (instancetype)ios7ArrowThinRightIconWithSize:(CGFloat)size;
+ (instancetype)ios7ArrowThinUpIconWithSize:(CGFloat)size;
+ (instancetype)ios7ArrowUpIconWithSize:(CGFloat)size;
+ (instancetype)ios7AtIconWithSize:(CGFloat)size;
+ (instancetype)ios7AtOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7BellIconWithSize:(CGFloat)size;
+ (instancetype)ios7BellOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7BoltIconWithSize:(CGFloat)size;
+ (instancetype)ios7BoltOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7BookmarksIconWithSize:(CGFloat)size;
+ (instancetype)ios7BookmarksOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7BoxIconWithSize:(CGFloat)size;
+ (instancetype)ios7BoxOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7BriefcaseIconWithSize:(CGFloat)size;
+ (instancetype)ios7BriefcaseOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7BrowsersIconWithSize:(CGFloat)size;
+ (instancetype)ios7BrowsersOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CalculatorIconWithSize:(CGFloat)size;
+ (instancetype)ios7CalculatorOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CalendarIconWithSize:(CGFloat)size;
+ (instancetype)ios7CalendarOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CameraIconWithSize:(CGFloat)size;
+ (instancetype)ios7CameraOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CartIconWithSize:(CGFloat)size;
+ (instancetype)ios7CartOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7ChatboxesIconWithSize:(CGFloat)size;
+ (instancetype)ios7ChatboxesOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7ChatbubbleIconWithSize:(CGFloat)size;
+ (instancetype)ios7ChatbubbleOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CheckmarkIconWithSize:(CGFloat)size;
+ (instancetype)ios7CheckmarkEmptyIconWithSize:(CGFloat)size;
+ (instancetype)ios7CheckmarkOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CircleFilledIconWithSize:(CGFloat)size;
+ (instancetype)ios7CircleOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7ClockIconWithSize:(CGFloat)size;
+ (instancetype)ios7ClockOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloseIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloseEmptyIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloseOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloudIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloudDownloadIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloudDownloadOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloudOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloudUploadIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloudUploadOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloudyIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloudyNightIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloudyNightOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CloudyOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CogIconWithSize:(CGFloat)size;
+ (instancetype)ios7CogOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7ComposeIconWithSize:(CGFloat)size;
+ (instancetype)ios7ComposeOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7ContactIconWithSize:(CGFloat)size;
+ (instancetype)ios7ContactOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7CopyIconWithSize:(CGFloat)size;
+ (instancetype)ios7CopyOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7DownloadIconWithSize:(CGFloat)size;
+ (instancetype)ios7DownloadOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7DragIconWithSize:(CGFloat)size;
+ (instancetype)ios7EmailIconWithSize:(CGFloat)size;
+ (instancetype)ios7EmailOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7EyeIconWithSize:(CGFloat)size;
+ (instancetype)ios7EyeOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7FastforwardIconWithSize:(CGFloat)size;
+ (instancetype)ios7FastforwardOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7FilingIconWithSize:(CGFloat)size;
+ (instancetype)ios7FilingOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7FilmIconWithSize:(CGFloat)size;
+ (instancetype)ios7FilmOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7FlagIconWithSize:(CGFloat)size;
+ (instancetype)ios7FlagOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7FolderIconWithSize:(CGFloat)size;
+ (instancetype)ios7FolderOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7GearIconWithSize:(CGFloat)size;
+ (instancetype)ios7GearOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7GlassesIconWithSize:(CGFloat)size;
+ (instancetype)ios7GlassesOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7HeartIconWithSize:(CGFloat)size;
+ (instancetype)ios7HeartOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7HelpIconWithSize:(CGFloat)size;
+ (instancetype)ios7HelpEmptyIconWithSize:(CGFloat)size;
+ (instancetype)ios7HelpOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7InfiniteIconWithSize:(CGFloat)size;
+ (instancetype)ios7InfiniteOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7InformationIconWithSize:(CGFloat)size;
+ (instancetype)ios7InformationEmptyIconWithSize:(CGFloat)size;
+ (instancetype)ios7InformationOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7IonicOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7KeypadIconWithSize:(CGFloat)size;
+ (instancetype)ios7KeypadOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7LightbulbIconWithSize:(CGFloat)size;
+ (instancetype)ios7LightbulbOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7LocationIconWithSize:(CGFloat)size;
+ (instancetype)ios7LocationOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7LockedIconWithSize:(CGFloat)size;
+ (instancetype)ios7LockedOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7MedkitIconWithSize:(CGFloat)size;
+ (instancetype)ios7MedkitOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7MicIconWithSize:(CGFloat)size;
+ (instancetype)ios7MicOffIconWithSize:(CGFloat)size;
+ (instancetype)ios7MicOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7MinusIconWithSize:(CGFloat)size;
+ (instancetype)ios7MinusEmptyIconWithSize:(CGFloat)size;
+ (instancetype)ios7MinusOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7MonitorIconWithSize:(CGFloat)size;
+ (instancetype)ios7MonitorOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7MoonIconWithSize:(CGFloat)size;
+ (instancetype)ios7MoonOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7MoreIconWithSize:(CGFloat)size;
+ (instancetype)ios7MoreOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7MusicalNoteIconWithSize:(CGFloat)size;
+ (instancetype)ios7MusicalNotesIconWithSize:(CGFloat)size;
+ (instancetype)ios7NavigateIconWithSize:(CGFloat)size;
+ (instancetype)ios7NavigateOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7PaperplaneIconWithSize:(CGFloat)size;
+ (instancetype)ios7PaperplaneOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7PartlysunnyIconWithSize:(CGFloat)size;
+ (instancetype)ios7PartlysunnyOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7PauseIconWithSize:(CGFloat)size;
+ (instancetype)ios7PauseOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7PeopleIconWithSize:(CGFloat)size;
+ (instancetype)ios7PeopleOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7PersonIconWithSize:(CGFloat)size;
+ (instancetype)ios7PersonOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7PersonaddIconWithSize:(CGFloat)size;
+ (instancetype)ios7PersonaddOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7PhotosIconWithSize:(CGFloat)size;
+ (instancetype)ios7PhotosOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7PieIconWithSize:(CGFloat)size;
+ (instancetype)ios7PieOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7PlayIconWithSize:(CGFloat)size;
+ (instancetype)ios7PlayOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7PlusIconWithSize:(CGFloat)size;
+ (instancetype)ios7PlusEmptyIconWithSize:(CGFloat)size;
+ (instancetype)ios7PlusOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7PricetagIconWithSize:(CGFloat)size;
+ (instancetype)ios7PricetagOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7PrinterIconWithSize:(CGFloat)size;
+ (instancetype)ios7PrinterOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7RainyIconWithSize:(CGFloat)size;
+ (instancetype)ios7RainyOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7RecordingIconWithSize:(CGFloat)size;
+ (instancetype)ios7RecordingOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7RedoIconWithSize:(CGFloat)size;
+ (instancetype)ios7RedoOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7RefreshIconWithSize:(CGFloat)size;
+ (instancetype)ios7RefreshEmptyIconWithSize:(CGFloat)size;
+ (instancetype)ios7RefreshOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7ReloadIconWithSize:(CGFloat)size;
+ (instancetype)ios7RewindIconWithSize:(CGFloat)size;
+ (instancetype)ios7RewindOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7SearchIconWithSize:(CGFloat)size;
+ (instancetype)ios7SearchStrongIconWithSize:(CGFloat)size;
+ (instancetype)ios7SkipbackwardIconWithSize:(CGFloat)size;
+ (instancetype)ios7SkipbackwardOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7SkipforwardIconWithSize:(CGFloat)size;
+ (instancetype)ios7SkipforwardOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7SnowyIconWithSize:(CGFloat)size;
+ (instancetype)ios7SpeedometerIconWithSize:(CGFloat)size;
+ (instancetype)ios7SpeedometerOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7StarIconWithSize:(CGFloat)size;
+ (instancetype)ios7StarOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7StopwatchIconWithSize:(CGFloat)size;
+ (instancetype)ios7StopwatchOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7SunnyIconWithSize:(CGFloat)size;
+ (instancetype)ios7SunnyOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7TelephoneIconWithSize:(CGFloat)size;
+ (instancetype)ios7TelephoneOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7ThunderstormIconWithSize:(CGFloat)size;
+ (instancetype)ios7ThunderstormOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7TimeIconWithSize:(CGFloat)size;
+ (instancetype)ios7TimeOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7TimerIconWithSize:(CGFloat)size;
+ (instancetype)ios7TimerOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7TrashIconWithSize:(CGFloat)size;
+ (instancetype)ios7TrashOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7UndoIconWithSize:(CGFloat)size;
+ (instancetype)ios7UndoOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7UnlockedIconWithSize:(CGFloat)size;
+ (instancetype)ios7UnlockedOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7UploadIconWithSize:(CGFloat)size;
+ (instancetype)ios7UploadOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7VideocamIconWithSize:(CGFloat)size;
+ (instancetype)ios7VideocamOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7VolumeHighIconWithSize:(CGFloat)size;
+ (instancetype)ios7VolumeLowIconWithSize:(CGFloat)size;
+ (instancetype)ios7WineglassIconWithSize:(CGFloat)size;
+ (instancetype)ios7WineglassOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ios7WorldIconWithSize:(CGFloat)size;
+ (instancetype)ios7WorldOutlineIconWithSize:(CGFloat)size;
+ (instancetype)ipadIconWithSize:(CGFloat)size;
+ (instancetype)iphoneIconWithSize:(CGFloat)size;
+ (instancetype)ipodIconWithSize:(CGFloat)size;
+ (instancetype)jetIconWithSize:(CGFloat)size;
+ (instancetype)keyIconWithSize:(CGFloat)size;
+ (instancetype)knifeIconWithSize:(CGFloat)size;
+ (instancetype)laptopIconWithSize:(CGFloat)size;
+ (instancetype)leafIconWithSize:(CGFloat)size;
+ (instancetype)levelsIconWithSize:(CGFloat)size;
+ (instancetype)lightbulbIconWithSize:(CGFloat)size;
+ (instancetype)linkIconWithSize:(CGFloat)size;
+ (instancetype)loadAIconWithSize:(CGFloat)size;
+ (instancetype)loadBIconWithSize:(CGFloat)size;
+ (instancetype)loadCIconWithSize:(CGFloat)size;
+ (instancetype)loadDIconWithSize:(CGFloat)size;
+ (instancetype)locationIconWithSize:(CGFloat)size;
+ (instancetype)lockedIconWithSize:(CGFloat)size;
+ (instancetype)logInIconWithSize:(CGFloat)size;
+ (instancetype)logOutIconWithSize:(CGFloat)size;
+ (instancetype)loopIconWithSize:(CGFloat)size;
+ (instancetype)magnetIconWithSize:(CGFloat)size;
+ (instancetype)maleIconWithSize:(CGFloat)size;
+ (instancetype)manIconWithSize:(CGFloat)size;
+ (instancetype)mapIconWithSize:(CGFloat)size;
+ (instancetype)medkitIconWithSize:(CGFloat)size;
+ (instancetype)micAIconWithSize:(CGFloat)size;
+ (instancetype)micBIconWithSize:(CGFloat)size;
+ (instancetype)micCIconWithSize:(CGFloat)size;
+ (instancetype)minusIconWithSize:(CGFloat)size;
+ (instancetype)minusCircledIconWithSize:(CGFloat)size;
+ (instancetype)minusRoundIconWithSize:(CGFloat)size;
+ (instancetype)modelSIconWithSize:(CGFloat)size;
+ (instancetype)monitorIconWithSize:(CGFloat)size;
+ (instancetype)moreIconWithSize:(CGFloat)size;
+ (instancetype)musicNoteIconWithSize:(CGFloat)size;
+ (instancetype)naviconIconWithSize:(CGFloat)size;
+ (instancetype)naviconRoundIconWithSize:(CGFloat)size;
+ (instancetype)navigateIconWithSize:(CGFloat)size;
+ (instancetype)noSmokingIconWithSize:(CGFloat)size;
+ (instancetype)nuclearIconWithSize:(CGFloat)size;
+ (instancetype)paperAirplaneIconWithSize:(CGFloat)size;
+ (instancetype)paperclipIconWithSize:(CGFloat)size;
+ (instancetype)pauseIconWithSize:(CGFloat)size;
+ (instancetype)personIconWithSize:(CGFloat)size;
+ (instancetype)personAddIconWithSize:(CGFloat)size;
+ (instancetype)personStalkerIconWithSize:(CGFloat)size;
+ (instancetype)pieGraphIconWithSize:(CGFloat)size;
+ (instancetype)pinIconWithSize:(CGFloat)size;
+ (instancetype)pinpointIconWithSize:(CGFloat)size;
+ (instancetype)pizzaIconWithSize:(CGFloat)size;
+ (instancetype)planeIconWithSize:(CGFloat)size;
+ (instancetype)playIconWithSize:(CGFloat)size;
+ (instancetype)playstationIconWithSize:(CGFloat)size;
+ (instancetype)plusIconWithSize:(CGFloat)size;
+ (instancetype)plusCircledIconWithSize:(CGFloat)size;
+ (instancetype)plusRoundIconWithSize:(CGFloat)size;
+ (instancetype)poundIconWithSize:(CGFloat)size;
+ (instancetype)powerIconWithSize:(CGFloat)size;
+ (instancetype)pricetagIconWithSize:(CGFloat)size;
+ (instancetype)pricetagsIconWithSize:(CGFloat)size;
+ (instancetype)printerIconWithSize:(CGFloat)size;
+ (instancetype)radioWavesIconWithSize:(CGFloat)size;
+ (instancetype)recordIconWithSize:(CGFloat)size;
+ (instancetype)refreshIconWithSize:(CGFloat)size;
+ (instancetype)replyIconWithSize:(CGFloat)size;
+ (instancetype)replyAllIconWithSize:(CGFloat)size;
+ (instancetype)searchIconWithSize:(CGFloat)size;
+ (instancetype)settingsIconWithSize:(CGFloat)size;
+ (instancetype)shareIconWithSize:(CGFloat)size;
+ (instancetype)shuffleIconWithSize:(CGFloat)size;
+ (instancetype)skipBackwardIconWithSize:(CGFloat)size;
+ (instancetype)skipForwardIconWithSize:(CGFloat)size;
+ (instancetype)socialAndroidIconWithSize:(CGFloat)size;
+ (instancetype)socialAndroidOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialAppleIconWithSize:(CGFloat)size;
+ (instancetype)socialAppleOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialBitcoinIconWithSize:(CGFloat)size;
+ (instancetype)socialBitcoinOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialBufferIconWithSize:(CGFloat)size;
+ (instancetype)socialBufferOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialDesignernewsIconWithSize:(CGFloat)size;
+ (instancetype)socialDesignernewsOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialDribbbleIconWithSize:(CGFloat)size;
+ (instancetype)socialDribbbleOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialDropboxIconWithSize:(CGFloat)size;
+ (instancetype)socialDropboxOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialFacebookIconWithSize:(CGFloat)size;
+ (instancetype)socialFacebookOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialFreebsdDevilIconWithSize:(CGFloat)size;
+ (instancetype)socialGithubIconWithSize:(CGFloat)size;
+ (instancetype)socialGithubOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialGoogleplusIconWithSize:(CGFloat)size;
+ (instancetype)socialGoogleplusOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialHackernewsIconWithSize:(CGFloat)size;
+ (instancetype)socialHackernewsOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialLinkedinIconWithSize:(CGFloat)size;
+ (instancetype)socialLinkedinOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialPinterestIconWithSize:(CGFloat)size;
+ (instancetype)socialPinterestOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialRedditIconWithSize:(CGFloat)size;
+ (instancetype)socialRedditOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialRssIconWithSize:(CGFloat)size;
+ (instancetype)socialRssOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialSkypeIconWithSize:(CGFloat)size;
+ (instancetype)socialSkypeOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialTumblrIconWithSize:(CGFloat)size;
+ (instancetype)socialTumblrOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialTuxIconWithSize:(CGFloat)size;
+ (instancetype)socialTwitterIconWithSize:(CGFloat)size;
+ (instancetype)socialTwitterOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialVimeoIconWithSize:(CGFloat)size;
+ (instancetype)socialVimeoOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialWindowsIconWithSize:(CGFloat)size;
+ (instancetype)socialWindowsOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialWordpressIconWithSize:(CGFloat)size;
+ (instancetype)socialWordpressOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialYahooIconWithSize:(CGFloat)size;
+ (instancetype)socialYahooOutlineIconWithSize:(CGFloat)size;
+ (instancetype)socialYoutubeIconWithSize:(CGFloat)size;
+ (instancetype)socialYoutubeOutlineIconWithSize:(CGFloat)size;
+ (instancetype)speakerphoneIconWithSize:(CGFloat)size;
+ (instancetype)speedometerIconWithSize:(CGFloat)size;
+ (instancetype)spoonIconWithSize:(CGFloat)size;
+ (instancetype)starIconWithSize:(CGFloat)size;
+ (instancetype)statsBarsIconWithSize:(CGFloat)size;
+ (instancetype)steamIconWithSize:(CGFloat)size;
+ (instancetype)stopIconWithSize:(CGFloat)size;
+ (instancetype)thermometerIconWithSize:(CGFloat)size;
+ (instancetype)thumbsdownIconWithSize:(CGFloat)size;
+ (instancetype)thumbsupIconWithSize:(CGFloat)size;
+ (instancetype)trashAIconWithSize:(CGFloat)size;
+ (instancetype)trashBIconWithSize:(CGFloat)size;
+ (instancetype)umbrellaIconWithSize:(CGFloat)size;
+ (instancetype)unlockedIconWithSize:(CGFloat)size;
+ (instancetype)uploadIconWithSize:(CGFloat)size;
+ (instancetype)usbIconWithSize:(CGFloat)size;
+ (instancetype)videocameraIconWithSize:(CGFloat)size;
+ (instancetype)volumeHighIconWithSize:(CGFloat)size;
+ (instancetype)volumeLowIconWithSize:(CGFloat)size;
+ (instancetype)volumeMediumIconWithSize:(CGFloat)size;
+ (instancetype)volumeMuteIconWithSize:(CGFloat)size;
+ (instancetype)waterdropIconWithSize:(CGFloat)size;
+ (instancetype)wifiIconWithSize:(CGFloat)size;
+ (instancetype)wineglassIconWithSize:(CGFloat)size;
+ (instancetype)womanIconWithSize:(CGFloat)size;
+ (instancetype)wrenchIconWithSize:(CGFloat)size;
+ (instancetype)xboxIconWithSize:(CGFloat)size;

@end


text:
/* global afterEach, before, beforeEach, describe, document, expect, inject, it, module, spyOn */
'use strict';

describe('Reading from $route service', function() {
  beforeEach(module('angular-google-analytics'));
  beforeEach(module(function (AnalyticsProvider) {
    AnalyticsProvider
      .setAccount('UA-XXXXXX-xx')
      .logAllCalls(true)
      .enterTestMode();
  }));

  afterEach(inject(function (Analytics) {
    Analytics.log.length = 0; // clear log
  }));

  it('should not activate $route reading', function() {
    inject(function(Analytics) {
      expect(Analytics.configuration.readFromRoute).toBe(false);
    });
  });

  describe('without $route service available', function() {
    beforeEach(module(function(AnalyticsProvider){
      AnalyticsProvider.readFromRoute(true);
    }));

    it('should log warning if service is missing', function() {
      inject(function($log) {
        spyOn($log, 'warn');
        inject(function(Analytics) {
          expect($log.warn).toHaveBeenCalledWith('$route service is not available. Make sure you have included ng-route in your application dependencies.');
        });
      });
    });
  });

  describe('after setting readFromRoute', function() {
    beforeEach(module(function(AnalyticsProvider, $provide){
      AnalyticsProvider.readFromRoute(true);
      $provide.service('$route', function () {
        this.routes = {
          someroute: { pageTrack: '/some' },
          otherroute: { }
        };
      });
    }));

    it('should activate $route reading', function(){
      inject(function(Analytics){
        expect(Analytics.configuration.readFromRoute).toBe(true);
      });
    });

    it('should read \'/someroute\' from routes object', function(){
      inject(function(Analytics, $route){
        $route.current = $route.routes.someroute;
        expect(Analytics.getUrl()).toBe('/some');
      });
    });

    it('should fallback to url for \'/otherroute\' without \'pageTrack\' property', function(){
      inject(function(Analytics, $route, $location){
        $route.current = $route.routes.otherroute;
        $location.url('/otherroute');
        expect(Analytics.getUrl()).toBe('/otherroute');
      });
    });

    it('should fallback to url for \'/undefinedroute\' which is not present in $route config', function(){
      inject(function(Analytics, $location) {
        $location.url('/undefinedroute');
        expect(Analytics.getUrl()).toBe('/undefinedroute');
      });
    });
  });

  describe('after setting readFromRoute for classic analytics', function() {
    beforeEach(module(function(AnalyticsProvider, $provide){
      AnalyticsProvider.readFromRoute(true)
                       .useAnalytics(false);
      $provide.service('$route', function () { });
    }));

    it('should not track undefined routes', function() {
      inject(function(Analytics, $window, $rootScope) {
        $window._gaq.length = 0; // clear queue
        $rootScope.$broadcast('$routeChangeSuccess');
        expect($window._gaq.length).toBe(0);
      });
    });

    it('should not track routes without template', function() {
      inject(function(Analytics, $window, $rootScope, $route) {
        $route.current = { };
        $window._gaq.length = 0; // clear queue
        $rootScope.$broadcast('$routeChangeSuccess');
        expect($window._gaq.length).toBe(0);
      });
    });

    it('should not track routes with \'doNotTrack\' attribute', function() {
      inject(function(Analytics, $window, $rootScope, $route) {
        $route.current = { templateUrl: '/myTemplate', doNotTrack: true };
        $window._gaq.length = 0; // clear queue
        $rootScope.$broadcast('$routeChangeSuccess');
        expect($window._gaq.length).toBe(0);
      });
    });

    it('should track routes with a defined template (no redirect)', function() {
      inject(function(Analytics, $window, $rootScope, $route) {
        $route.current = { templateUrl: '/myTemplate', pageTrack: '/myTrack' };
        $window._gaq.length = 0; // clear queue
        $rootScope.$broadcast('$routeChangeSuccess');
        expect($window._gaq.length).toBe(2);
        expect($window._gaq[0]).toEqual(['_set', 'title', '']);
        expect($window._gaq[1]).toEqual(['_trackPageview', '/myTrack']);
      });
    });
  });

  describe('after setting readFromRoute for universal analytics', function() {
    beforeEach(module(function(AnalyticsProvider, $provide){
      AnalyticsProvider.readFromRoute(true)
                       .useAnalytics(true);
      $provide.service('$route', function () { });
    }));

    it('should not track undefined routes', function() {
      inject(function(Analytics, $rootScope) {
        Analytics.log.length = 0; // clear queue
        $rootScope.$broadcast('$routeChangeSuccess');
        expect(Analytics.log.length).toBe(0);
      });
    });

    it('should not track routes without template', function() {
      inject(function(Analytics, $rootScope, $route) {
        $route.current = { };
        Analytics.log.length = 0; // clear queue
        $rootScope.$broadcast('$routeChangeSuccess');
        expect(Analytics.log.length).toBe(0);
      });
    });

    it('should not track routes with \'doNotTrack\' attribute', function() {
      inject(function(Analytics, $rootScope, $route) {
        $route.current = { templateUrl: '/myTemplate', doNotTrack: true };
        Analytics.log.length = 0; // clear queue
        $rootScope.$broadcast('$routeChangeSuccess');
        expect(Analytics.log.length).toBe(0);
      });
    });

    it('should track routes with a defined template (no redirect)', function() {
      inject(function(Analytics, $window, $rootScope, $route) {
        $route.current = { templateUrl: '/myTemplate', pageTrack: '/myTrack' };
        Analytics.log.length = 0; // clear queue
        $rootScope.$broadcast('$routeChangeSuccess');
        expect(Analytics.log.length).toBe(1);
        expect(Analytics.log[0]).toEqual(['send', 'pageview', { page: '/myTrack', title: '' }]);
      });
    });
  });
});


text:
package cmd

import (
	"github.com/atongen/gosaic/controller"

	"github.com/spf13/cobra"
)

var (
	macroQuadWidth        int
	macroQuadHeight       int
	macroQuadSize         int
	macroQuadMinDepth     int
	macroQuadMaxDepth     int
	macroQuadMinArea      int
	macroQuadMaxArea      int
	macroQuadCoverOutfile string
	macroQuadMacroOutfile string
)

func init() {
	addLocalIntFlag(&macroQuadWidth, "width", "w", 0, "Pixel width of cover, 0 maintains aspect from height", MacroQuadCmd)
	addLocalIntFlag(&macroQuadHeight, "height", "", 0, "Pixel height of cover, 0 maintains aspect from width", MacroQuadCmd)
	addLocalIntFlag(&macroQuadSize, "size", "s", -1, "Number of times to subdivide the image into quads", MacroQuadCmd)
	addLocalIntFlag(&macroQuadMinDepth, "min-depth", "", -1, "Minimum depth of quad subdivisions", MacroQuadCmd)
	addLocalIntFlag(&macroQuadMaxDepth, "max-depth", "", -1, "Maximum depth of quad subdivisions", MacroQuadCmd)
	addLocalIntFlag(&macroQuadMinArea, "min-area", "", -1, "Minimum area of quad subdivisions", MacroQuadCmd)
	addLocalIntFlag(&macroQuadMinArea, "max-area", "", -1, "Maxumum area of quad subdivisions", MacroQuadCmd)
	addLocalStrFlag(&macroQuadCoverOutfile, "cover-out", "", "", "File to write cover image", MacroQuadCmd)
	addLocalStrFlag(&macroQuadMacroOutfile, "out", "o", "", "File to write resized macro image", MacroQuadCmd)
	RootCmd.AddCommand(MacroQuadCmd)
}

var MacroQuadCmd = &cobra.Command{
	Use:    "macro_quad PATH",
	Short:  "Add quad cover and macro",
	Long:   "Add quad cover and macro",
	Hidden: true,
	Run: func(c *cobra.Command, args []string) {
		if len(args) != 1 {
			Env.Fatalln("PATH is required")
		}

		if args[0] == "" {
			Env.Fatalln("Macro path is required")
		}

		if macroQuadWidth < 0 {
			Env.Fatalln("width must be greater than zero")
		}

		if macroQuadHeight < 0 {
			Env.Fatalln("height must be greater than zero")
		}

		if macroQuadSize == 0 &&
			macroQuadMinDepth == 0 &&
			macroQuadMaxDepth == 0 &&
			macroQuadMinArea == 0 &&
			macroQuadMaxArea == 0 {
			Env.Fatalln("Add least one of size, min-depth, max-depth, min-area, or max-area must be non-zero.")
		}

		err := Env.Init()
		if err != nil {
			Env.Fatalf("Unable to initialize environment: %s\n", err.Error())
		}
		defer Env.Close()

		controller.MacroQuad(
			Env,
			args[0],
			macroQuadWidth,
			macroQuadHeight,
			macroQuadSize,
			macroQuadMinDepth,
			macroQuadMaxDepth,
			macroQuadMinArea,
			macroQuadMaxArea,
			macroQuadCoverOutfile,
			macroQuadMacroOutfile,
		)
	},
}