text:
package test;

class Bar {
    public static @interface Foo {}
}
@Bar.<caret>Foo
public class OOO {
}

redpajama_set_name: RedPajamaGithub


text:
CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY
--------------------------------------

Skip :ref:`User Package Registry` in :command:`find_package` calls.

In some cases, for example to locate only system wide installations, it
is not desirable to use the :ref:`User Package Registry` when searching
for packages. If the :variable:`CMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY`
variable is enabled, all the :command:`find_package` commands will skip
the :ref:`User Package Registry` as if they were called with the
``NO_CMAKE_PACKAGE_REGISTRY`` argument.

See also :ref:`Disabling the Package Registry`.


text:
<!doctype html>

    <link rel="stylesheet" type="text/css" href="client/styles/explorer.css">


text:
// Copyright 2004-present Facebook. All Rights Reserved.

#pragma once

#include <cxxreact/JSExecutor.h>
#include <fb/fbjni.h>
#include <jni.h>
#include <jni/GlobalReference.h>
#include "OnLoad.h"

namespace facebook {
namespace react {

/**
 * This executor factory can only create a single executor instance because it moves
 * executorInstance global reference to the executor instance it creates.
 */
class ProxyExecutorOneTimeFactory : public JSExecutorFactory {
public:
  ProxyExecutorOneTimeFactory(jni::global_ref<jobject>&& executorInstance) :
    m_executor(std::move(executorInstance)) {}
  virtual std::unique_ptr<JSExecutor> createJSExecutor(
    std::shared_ptr<ExecutorDelegate> delegate,
    std::shared_ptr<MessageQueueThread> queue) override;

private:
  jni::global_ref<jobject> m_executor;
};

class ProxyExecutor : public JSExecutor {
public:
  ProxyExecutor(jni::global_ref<jobject>&& executorInstance,
                std::shared_ptr<ExecutorDelegate> delegate);
  virtual ~ProxyExecutor() override;
  virtual void loadApplicationScript(
    std::unique_ptr<const JSBigString> script,
    std::string sourceURL) override;
  virtual void setBundleRegistry(
    std::unique_ptr<RAMBundleRegistry> bundle) override;
  virtual void registerBundle(
    uint32_t bundleId, const std::string& bundlePath) override;
  virtual void callFunction(
    const std::string& moduleId,
    const std::string& methodId,
    const folly::dynamic& arguments) override;
  virtual void invokeCallback(
    const double callbackId,
    const folly::dynamic& arguments) override;
  virtual void setGlobalVariable(
    std::string propName,
    std::unique_ptr<const JSBigString> jsonValue) override;
  virtual std::string getDescription() override;

private:
  jni::global_ref<jobject> m_executor;
  std::shared_ptr<ExecutorDelegate> m_delegate;
};

} }


text:
#ifndef __VECTOR_H__
#define __VECTOR_H__

#include "freetypy.h"

PyObject *
Py_Vector_cnew(FT_Vector *Vector, double scale);

int setup_Vector(PyObject *m);

#endif


text:
layout: help
title: "Help Page Both"
sub-title: "Instantly and automatically receive email and text message notifications from your users and forms."
author: "Jeff"
permalink: /help-page-4/
help-class: [the basics, customization]
---

So! Your Wufoo forms are all setup and you're already gathering tons of entries and data from your users and customers. Congrats. But wait—want a simple trick to super-power your forms? You do? Then you need something.

In our first Back to [Basics](/) post, we showed you how and why you'd want to limit the number of entries your form received. This time around, I'll show you how to easily setup notifications for all of your forms. You'll get an instant heads-up of when a new form submission comes in so you won't need to worry about missing a request, sales lead, or any other entry for that matter. It's by far one of the more features Wufoo offers.

## 1. Simple Email Notifications

More text here

## 2. Text Message Notifications

Okay, simple email notifications are cool and all, but mobile's all the rage these days, amirite? Well, Wufoo has you covered there too. You can setup text message notifications so that you'll get a text whenever someone fills our your form.


text:
namespace grpc_core {
extern const char* kRequestRingHashAttribute;

// Helper Parsing method to parse ring hash policy configs; for example, ring
// hash size validity.
void ParseRingHashLbConfig(const Json& json, size_t* min_ring_size,
                           size_t* max_ring_size,
                           std::vector<grpc_error_handle>* error_list);
}  // namespace grpc_core

#endif  // GRPC_CORE_EXT_FILTERS_CLIENT_CHANNEL_LB_POLICY_RING_HASH_RING_HASH_H


text:
using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;

namespace Hellgate
{
    public class SelectORMMaker : SQLMaker
    {
        private class TableInfo
        {
            public Type type;
            public string tableName;
            public Type parentType;

            public TableInfo (Type type, string tableName, Type parentType = null)
            {
                this.type = type;
                this.tableName = tableName;
                this.parentType = parentType;
            }
        }

        private List<TableInfo> tableInfos;
        private List<string> selects;
        private List<string> tables;
        private List<string> wheres;
        private List<string> joins;
        private List<string> joinsQuerys;
        private Type type;
        private SqliteJoinType joinType;
        private string tableName;

        /// <summary>
        /// Gets the table type.
        /// </summary>
        /// <value>The type.</value>
        public Type Type {
            get {
                return type;
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="Hellgate.SelectORMMaker"/> class.
        /// </summary>
        /// <param name="type">Type.</param>
        /// <param name="tableName">Table name.</param>
        public SelectORMMaker (Type type, string tableName)
        {
            this.type = type;
            this.tableName = tableName;
            if (this.tableName == "") {
                this.tableName = Query.GetTableName (type);
            }

            selects = new List<string> ();
            tables = new List<string> ();
            wheres = new List<string> ();
            joins = new List<string> ();
            joinsQuerys = new List<string> ();

            tableInfos = new List<TableInfo> ();
            tableInfos.Add (new TableInfo (this.type, this.tableName));
            tables.Add (this.tableName);
        }

        /// <summary>
        /// Sets the type.
        /// </summary>
        /// <returns>The type.</returns>
        /// <param name="type">Type.</param>
        /// <param name="index">Index.</param>
        public string SetType (Type type, Type parent = null)
        {
            if (type == null) {
                this.type = type;
                return "";
            }

            this.type = type;
            this.tableName = Query.GetTableName (type);

            if (this.tableName != "") {
                if (!tables.Contains (this.tableName)) {
                    tableInfos.Add (new TableInfo (this.type, this.tableName, parent));
                    tables.Add (this.tableName);
                }
            }

            return this.tableName;
        }

        /// <summary>
        /// Sets the select.
        /// </summary>
        /// <param name="fieldName">Field name.</param>
        public void SetSelect (string fieldName)
        {
            selects.Add (GenerateSelectAliasSQL (this.tableName, fieldName));
        }

        /// <summary>
        /// Sets the join.
        /// </summary>
        /// <param name="fieldName">Field name.</param>
        /// <param name="joinTable">Join table.</param>
        /// <param name="joinFieldName">Join field name.</param>
        public void SetJoin (Type tableType, string fieldName, string joinFieldName)
        {
            string tableName = Query.GetTableName (tableType);
            string joinQuery = GenerateJoinSQL (tableName, this.tableName, fieldName, joinFieldName, joinType);

            if (joinQuery == "") {
                string key = Period (tableName, joinFieldName);
                string value = Period (this.tableName, fieldName);
                wheres.Add (EqualsSign (key, value));
            } else {
                joins.Add (this.tableName);
                joinsQuerys.Add (joinQuery);
            }
        }

        /// <summary>
        /// Sets the type of the join.
        /// </summary>
        /// <param name="joinType">Join type.</param>
        public void SetJoinType (SqliteJoinType joinType = SqliteJoinType.None)
        {
            this.joinType = joinType;
        }

        /// <summary>
        /// Execute this instance.
        /// </summary>
        public string GetQuery (string addQuery = "")
        {
            if (joins.Count > 0) {
                foreach (string j in joins) {
                    if (tables.Contains (j)) {
                        tables.Remove (j);
                    }
                }
            }

            return GenerateSelectSQL (selects, tables, joinsQuerys, wheres, addQuery);
        }
    }

    public partial class Query
    {
        protected System.Reflection.BindingFlags blindingFlags = System.Reflection.BindingFlags.NonPublic;

        /// <summary>
        /// Sets the blinding flags.
        /// Only BindingFlags.NonPublic and BindingFlags.Public
        /// </summary>
        /// <value>The blinding flags.</value>
        public System.Reflection.BindingFlags BlindingFlags {
            set {
                if (value == System.Reflection.BindingFlags.NonPublic || value == System.Reflection.BindingFlags.Public) {
                    blindingFlags = value;
                } else {
                    HDebug.LogWarning ("Only BindingFlags.NonPublic and BindingFlags.Public");
                }
            }
        }

        /// <summary>
        /// Cleans the useless.
        /// </summary>
        /// <returns>The useless.</returns>
        /// <param name="data">Data.</param>
        protected Dictionary<string, object> CleanUseless (Dictionary<string, object> data)
        {
            Dictionary<string, object> temp = new Dictionary<string, object> ();
            foreach (KeyValuePair<string, object> pair in data) {
                if (pair.Value != null) {
                    if (Util.IsValueType (pair.Value.GetType ())) {
                        temp.Add (pair.Key, pair.Value);
                    }
                }
            }

            return temp;
        }

        /// <summary>
        /// INSERT the specified tableName and t.
        /// </summary>
        /// <param name="tableName">Table name.</param>
        /// <param name="t">T.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        protected void INSERT<T> (string tableName, T t)
        {
            Dictionary<string, object> data = Reflection.Convert<T> (t, null, blindingFlags);
            data = CleanUseless (data);

            INSERT (tableName, data);
        }

        /// <summary>
        /// INSERT the specified t.
        /// </summary>
        /// <param name="t">T.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        public void INSERT<T> (T t)
        {
            INSERT<T> (GetTableName<T> (), t);
        }

        /// <summary>
        /// INSERT BATCH.
        /// </summary>
        /// <param name="tableName">Table name.</param>
        /// <param name="list">List.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        protected void INSERT_BATCH<T> (string tableName, List<T> list)
        {
            List<Dictionary<string, object>> data = Reflection.Convert<T> (list, blindingFlags);

            string[] columns = null;
            string[][] qData = new string[data.Count][];
            for (int i = 0; i < data.Count; i++) {
                data [i] = CleanUseless (data [i]);

                string[] temp = new string[data [i].Count];
                int index = 0;
                foreach (KeyValuePair<string, object> pair in data [i]) {
                    if (i == 0) {
                        if (columns == null) {
                            columns = new string[data [i].Count];
                        }
                        columns [index] = pair.Key;
                    }

                    temp [index] = pair.Value.ToString ();
                    index++;
                }

                qData [i] = temp;
            }

            INSERT_BATCH (tableName, columns, qData);
        }

        /// <summary>
        /// INSERT BATCH.
        /// </summary>
        /// <param name="list">List.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        public void INSERT_BATCH<T> (List<T> list)
        {
            INSERT_BATCH<T> (GetTableName<T> (), list);
        }

        /// <summary>
        /// INSERT BATCH.
        /// </summary>
        /// <param name="list">List.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        public void INSERT_BATCH<T> (T[] list)
        {
            INSERT_BATCH<T> (GetTableName<T> (), new List<T> (list));
        }

        /// <summary>
        /// UPDATE the specified t and addQuery.
        /// </summary>
        /// <param name="t">T.</param>
        /// <param name="addQuery">Add query.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        public void UPDATE<T> (T t, string addQuery)
        {
            Dictionary<string, object> data = Reflection.Convert<T> (t, null, blindingFlags);
            data = CleanUseless (data);

            UPDATE (GetTableName<T> (), data, addQuery);
        }

        /// <summary>
        /// UPDATE the specified t, key and value.
        /// </summary>
        /// <param name="t">T.</param>
        /// <param name="key">Key.</param>
        /// <param name="value">Value.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        public void UPDATE<T> (T t, string key, object value)
        {
            UPDATE<T> (t, GenerateWhereKeyValueSQL (key, value));
        }

        /// <summary>
        /// SELECT the specified tableName and addQuery.
        /// </summary>
        /// <param name="tableName">Table name.</param>
        /// <param name="addQuery">Add query.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        protected T[] SELECT<T> (string tableName, string addQuery)
        {
            if (tableName == "") {
                return null;
            }

            SelectORMMaker mapper = new SelectORMMaker (typeof(T), tableName);
            mapper = Reflection.SetSelectORMMaker (mapper, blindingFlags);

            DataTable data = ExecuteQuery (mapper.GetQuery (addQuery));
            if (data == null || data.Rows.Count <= 0) {
                return null;
            }

            return Reflection.Convert<T> (data, blindingFlags);
        }

        /// <summary>
        /// SELECT the specified addQuery.
        /// </summary>
        /// <param name="addQuery">Add query.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        public T[] SELECT<T> (string addQuery = "")
        {
            return SELECT<T> (GetTableName<T> (), addQuery);
        }

        /// <summary>
        /// SELECT the specified key and value.
        /// </summary>
        /// <param name="key">Key.</param>
        /// <param name="value">Value.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        public T[] SELECT<T> (string key, object value)
        {
            return SELECT<T> (GetTableName<T> (), GenerateWhereKeyValueSQL (key, value));
        }

        /// <summary>
        /// DELETE the specified addQuery.
        /// </summary>
        /// <param name="addQuery">Add query.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        public void DELETE<T> (string addQuery = "")
        {
            DELETE (GetTableName<T> (), addQuery);
        }

        /// <summary>
        /// DELETE the specified key and value.
        /// </summary>
        /// <param name="key">Key.</param>
        /// <param name="value">Value.</param>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        public void DELETE<T> (string key, object value)
        {
            DELETE (GetTableName<T> (), key, value);
        }

        /// <summary>
        /// Gets the name of the table.
        /// </summary>
        /// <returns>The table name.</returns>
        /// <param name="type">Type.</param>
        public static string GetTableName (Type type)
        {
            TableAttribute table = type.GetAttributeValue<TableAttribute> ();

            if (table == null) {
                HDebug.LogError ("Not set the table attribute.");
                return "";
            } else if (table.TableName == "") {
                return type.Name;
            } else {
                return table.TableName;
            }
        }

        /// <summary>
        /// Gets the name of the table.
        /// </summary>
        /// <returns>The table name.</returns>
        /// <typeparam name="T">The 1st type parameter.</typeparam>
        public static string GetTableName<T> ()
        {
            return GetTableName (typeof(T));
        }
    }
}


text:
// Authors: jmarantz@google.com (Joshua Marantz)
//          jefftk@google.com (Jeff Kaufman)

#include "net/instaweb/rewriter/public/resource_tag_scanner.h"

#include "net/instaweb/rewriter/public/css_tag_scanner.h"
#include "net/instaweb/rewriter/public/rewrite_options.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/html/html_element.h"
#include "pagespeed/kernel/html/html_name.h"
#include "pagespeed/kernel/http/semantic_type.h"

namespace net_instaweb {
namespace resource_tag_scanner {

const char kIcon[] = "icon";  // favicons

// See http://developer.apple.com/library/ios/#DOCUMENTATION/
//   AppleApplications/Reference/SafariWebContent/ConfiguringWebApplications/
//   ConfiguringWebApplications.html
const char kAppleTouchIcon[] = "apple-touch-icon";
const char kAppleTouchIconPrecomposed[] = "apple-touch-icon-precomposed";
const char kAppleTouchStartupImage[] = "apple-touch-startup-image";

// Below are the values of the "rel" attribute of LINK tag which are relevant to
// DNS prefetch.
const char kRelPrefetch[] = "prefetch";
const char kRelDnsPrefetch[] = "dns-prefetch";

const char kAttrValImage[] = "image";  // <input type="image" src=...>

namespace {

bool IsAttributeValid(HtmlElement::Attribute* attr) {
  return attr != NULL && !attr->decoding_error();
}

semantic_type::Category CategorizeAttributeBySpec(
    const HtmlElement* element, HtmlName::Keyword attribute_name) {
  switch (element->keyword()) {
    case HtmlName::kLink: {
      // See http://www.whatwg.org/specs/web-apps/current-work/multipage/links.html#linkTypes
      if (attribute_name != HtmlName::kHref) {
        return semantic_type::kUndefined;
      }
      const HtmlElement::Attribute* rel_attr =
          element->FindAttribute(HtmlName::kRel);
      if (rel_attr == NULL) {
        return semantic_type::kHyperlink;
      }
      if (CssTagScanner::IsStylesheetOrAlternate(
              rel_attr->DecodedValueOrNull())) {
        return semantic_type::kStylesheet;
      }
      // Ignore keywords we don't recognize, to deal with cases like
      // "shortcut icon" where shortcut is simply ignored.
      StringPieceVector values;
      SplitStringPieceToVector(rel_attr->DecodedValueOrNull(),
                               " ", &values, true /* skip empty */);
      // Image takes precedence over prefetch, so look for images first.
      for (int i = 0, n = values.size(); i < n; ++i) {
        if (StringCaseEqual(values[i], kIcon) ||
            StringCaseEqual(values[i], kAppleTouchIcon) ||
            StringCaseEqual(values[i], kAppleTouchIconPrecomposed) ||
            StringCaseEqual(values[i], kAppleTouchStartupImage)) {
          return semantic_type::kImage;
        }
      }
      for (int i = 0, n = values.size(); i < n; ++i) {
        if (StringCaseEqual(values[i], kRelPrefetch) ||
            StringCaseEqual(values[i], kRelDnsPrefetch)) {
          return semantic_type::kPrefetch;
        }
      }
      return semantic_type::kUndefined;
    }
    case HtmlName::kScript:
      return (attribute_name == HtmlName::kSrc ?
              semantic_type::kScript : semantic_type::kUndefined);
    case HtmlName::kImg:
      if (attribute_name == HtmlName::kSrc) {
        return semantic_type::kImage;
      }
      if (attribute_name == HtmlName::kLongdesc) {
        return semantic_type::kHyperlink;
      }
      return semantic_type::kUndefined;
    case HtmlName::kBody:
      if (attribute_name == HtmlName::kBackground) {
        return semantic_type::kImage;
      }
      if (attribute_name == HtmlName::kCite) {
        return semantic_type::kHyperlink;
      }
      return semantic_type::kUndefined;
    case HtmlName::kTd:
    case HtmlName::kTh:
    case HtmlName::kTable:
    case HtmlName::kTbody:
    case HtmlName::kTfoot:
    case HtmlName::kThead:
      return (attribute_name == HtmlName::kBackground ?
              semantic_type::kImage : semantic_type::kUndefined);
    case HtmlName::kInput:
      if (attribute_name == HtmlName::kFormaction) {
        return semantic_type::kHyperlink;
      }
      if (StringCaseEqual(element->AttributeValue(HtmlName::kType),
                          kAttrValImage) &&
          attribute_name == HtmlName::kSrc) {
        return semantic_type::kImage;
      }
      return semantic_type::kUndefined;
    case HtmlName::kCommand:
      return (attribute_name == HtmlName::kIcon ?
              semantic_type::kImage : semantic_type::kUndefined);
    case HtmlName::kA:
    case HtmlName::kArea:
      return (attribute_name == HtmlName::kHref ?
              semantic_type::kHyperlink : semantic_type::kUndefined);
    case HtmlName::kForm:
      return (attribute_name == HtmlName::kAction ?
              semantic_type::kHyperlink : semantic_type::kUndefined);
    case HtmlName::kVideo:
      if (attribute_name == HtmlName::kSrc) {
        return semantic_type::kOtherResource;
      }
      if (attribute_name == HtmlName::kPoster) {
        return semantic_type::kImage;
      }
      return semantic_type::kUndefined;
    case HtmlName::kAudio:
    case HtmlName::kSource:
    case HtmlName::kTrack:
    case HtmlName::kEmbed:
      return (attribute_name == HtmlName::kSrc ?
              semantic_type::kOtherResource : semantic_type::kUndefined);
    case HtmlName::kFrame:
    case HtmlName::kIframe:
      if (attribute_name == HtmlName::kSrc) {
        return semantic_type::kOtherResource;
      }
      if (attribute_name == HtmlName::kLongdesc) {
        return semantic_type::kHyperlink;
      }
      return semantic_type::kUndefined;
    case HtmlName::kHtml:
      return (attribute_name == HtmlName::kManifest ?
              semantic_type::kOtherResource : semantic_type::kUndefined);
    case HtmlName::kBlockquote:
    case HtmlName::kQ:
    case HtmlName::kIns:
    case HtmlName::kDel:
      return (attribute_name == HtmlName::kCite ?
              semantic_type::kHyperlink : semantic_type::kUndefined);
    case HtmlName::kButton:
      return (attribute_name == HtmlName::kFormaction ?
              semantic_type::kHyperlink : semantic_type::kUndefined);
    default:
      break;
  }
  return semantic_type::kUndefined;
}

}  // namespace

semantic_type::Category CategorizeAttribute(
    const HtmlElement* element,
    const HtmlElement::Attribute* attribute,
    const RewriteOptions* options) {

  if (attribute == NULL) {
    return semantic_type::kUndefined;
  }

  // Handle user-defined attributes.  Do this first so spec-defined attributes
  // can be overriden.
  for (int i = 0, n = options->num_url_valued_attributes(); i < n; ++i) {
    StringPiece element_i;
    StringPiece attribute_i;
    semantic_type::Category category_i;
    options->UrlValuedAttribute(i, &element_i, &attribute_i, &category_i);
    if (StringCaseEqual(element->name_str(), element_i) &&
        StringCaseEqual(attribute->name_str(), attribute_i)) {
      return category_i;
    }
  }

  // Handle spec-defined attributes.
  semantic_type::Category spec_category =
      CategorizeAttributeBySpec(element, attribute->keyword());
  if (spec_category != semantic_type::kUndefined) {
    return spec_category;
  }

  return semantic_type::kUndefined;
}

void ScanElement(HtmlElement* element,
                 const RewriteOptions* options,
                 UrlCategoryVector* attributes) {
  HtmlElement::AttributeList* attrs = element->mutable_attributes();
  for (HtmlElement::AttributeIterator i = attrs->begin();
       i != attrs->end(); ++i) {
    UrlCategoryPair url_category_pair;
    url_category_pair.url = i.Get();
    if (IsAttributeValid(url_category_pair.url)) {
      url_category_pair.category = CategorizeAttribute(
          element, url_category_pair.url, options);
      if (url_category_pair.category != semantic_type::kUndefined) {
        attributes->push_back(url_category_pair);
      }
    }
  }
}

}  // namespace resource_tag_scanner
}  // namespace net_instaweb


text:
package org.elasticsearch.script;

/**
 * An executable script, can't be used concurrently.
 */
public interface ExecutableScript {

    /**
     * Sets a runtime script parameter.
     * <p>
     * Note that this method may be slow, involving put() and get() calls
     * to a hashmap or similar.
     * @param name parameter name
     * @param value parameter value
     */
    void setNextVar(String name, Object value);

    /**
     * Executes the script.
     */
    Object run();

    /**
     * Unwraps a possible script value. For example, when passing vars and
     * expecting the returned value to be part of the vars. Javascript and
     * Python need this but other scripting engines just return the values
     * passed in.
     */
    default Object unwrap(Object value) {
        return value;
    }
}


text:
import play.filters.cors.CORSFilter
import play.http._

class Filters (corsFilter: CORSFilter)
  extends DefaultHttpFilters(corsFilter)


text:
<?php
defined('BASEPATH') OR exit('No direct script access allowed');

class Sign_inModel extends CI_Model{

    function __construct(){

    }

    function authenticate($user,$password){
        $sql = "SELECT * FROM user WHERE username = ? AND AES_DECRYPT(password,'webproject') = ?";
        $autenthicated = $this->db->query($sql, array($user,$password));
        return $autenthicated->num_rows() > 0;
    }

    function send_permissions($user,$password){
        $sql = "SELECT p.name FROM (SELECT rp.id_permissions FROM (SELECT ur.id_rol FROM (SELECT Id FROM user WHERE username = ? AND AES_DECRYPT(password,'webproject') = ?) u INNER JOIN user_rol ur ON u.Id = ur.id_user) uur INNER JOIN rol_permissions rp ON uur.id_rol = rp.id_rol) uurrp INNER JOIN permissions p ON uurrp.id_permissions = p.Id";
        $permissionsUsers = $this->db->query($sql, array($user,$password))->result_array();

        $sql = "SELECT name FROM permissions";
        $permissions = $this->db->query($sql)->result_array();

        $arrayPermisions = [];
        foreach($permissions as $permission){
            $arrayPermisions[$permission['name']]= false;
        }

        foreach($permissionsUsers as $permissionUser){
            $arrayPermisions[$permissionUser['name']]= true;
        }

        return $arrayPermisions;
    }

    function send_personal_data($user,$password){
        $sql = "SELECT * FROM user WHERE username = ? AND AES_DECRYPT(password,'webproject') = ?";
        return $this->db->query($sql, array($user,$password))->result_array();
    }

    function send_rols($user,$password){
        $sql = "SELECT r.name FROM (SELECT ur.id_rol FROM (SELECT Id FROM user WHERE username = ? AND AES_DECRYPT(password,'webproject') = ?) u INNER JOIN user_rol ur ON u.Id = ur.id_user) uur INNER JOIN rol r ON uur.id_rol = r.Id";
        $rolsUsers = $this->db->query($sql, array($user,$password))->result_array();

        $sql = "SELECT * FROM rol";
        $rols = $this->db->query($sql)->result_array();

        $arrayRols = [];
        foreach($rols as $rol){
            $arrayRols[$rol['name']] = false;
        }

        foreach($rolsUsers as $rolsUser){
            $arrayRols[$rolsUser['name']] = true;
        }

        return $arrayRols;

    }

}


text:
package com.digitaslbi.selenium.html;

import com.digitaslbi.selenium.common.controls.BaseElement;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;

public abstract class Input extends BaseElement {
    public Input(By by, String description, BaseElement parent) {
        super(by, description, parent);
    }

    public Input(WebElement webElement, String description) {
        super(webElement, description);
    }

    public abstract void fill();
}


text:
using System;

namespace SimpleDnsCrypt.Models
{
	public class AddressBlockLogLine : LogLine
	{
		public DateTime Time { get; set; }
		public string Host { get; set; }
		public string QName { get; set; }
		public string Message { get; set; }

		public AddressBlockLogLine(string line)
		{
			try
			{

			}
			catch (Exception)
			{
			}
		}
	}
}


text:
package dnsimple

import (
	"fmt"
	"strconv"
)

type RecordResponse struct {
	Record Record `json:"record"`
}

// Record is used to represent a retrieved Record. All properties
// are set as strings.
type Record struct {
	Name       string `json:"name"`
	Content    string `json:"content"`
	DomainId   int64  `json:"domain_id"`
	Id         int64  `json:"id"`
	Prio       int64  `json:"prio"`
	RecordType string `json:"record_type"`
	Ttl        int64  `json:"ttl"`
}

// Returns the domain id
func (r *Record) StringDomainId() string {
	return strconv.FormatInt(r.DomainId, 10)
}

// Returns the id
func (r *Record) StringId() string {
	return strconv.FormatInt(r.Id, 10)
}

// Returns the string for prio
func (r *Record) StringPrio() string {
	return strconv.FormatInt(r.Prio, 10)
}

// Returns the string for Locked
func (r *Record) StringTtl() string {
	return strconv.FormatInt(r.Ttl, 10)
}

// ChangeRecord contains the request parameters to create or update a
// record.
type ChangeRecord struct {
	Name  string // name of the record
	Value string // where the record points
	Type  string // type, i.e a, mx
	Ttl   string // TTL of record
}

// CreateRecord creates a record from the parameters specified and
// returns an error if it fails. If no error and an ID is returned,
// the Record was succesfully created.
func (c *Client) CreateRecord(domain string, opts *ChangeRecord) (string, error) {
	// Make the request parameters
	params := make(map[string]interface{})

	params["name"] = opts.Name
	params["record_type"] = opts.Type
	params["content"] = opts.Value

	if opts.Ttl != "" {
		ttl, err := strconv.ParseInt(opts.Ttl, 0, 0)
		if err != nil {
			return "", nil
		}
		params["ttl"] = ttl
	}

	endpoint := fmt.Sprintf("/domains/%s/records", domain)

	req, err := c.NewRequest(params, "POST", endpoint)
	if err != nil {
		return "", err
	}

	resp, err := checkResp(c.Http.Do(req))
	if err != nil {
		return "", fmt.Errorf("Error creating record: %s", err)
	}

	record := new(RecordResponse)

	err = decodeBody(resp, &record)

	if err != nil {
		return "", fmt.Errorf("Error parsing record response: %s", err)
	}

	// The request was successful
	return record.Record.StringId(), nil
}

// UpdateRecord updated a record from the parameters specified and
// returns an error if it fails.
func (c *Client) UpdateRecord(domain string, id string, opts *ChangeRecord) (string, error) {
	// Make the request parameters
	params := make(map[string]interface{})

	if opts.Name != "" {
		params["name"] = opts.Name
	}

	if opts.Type != "" {
		params["record_type"] = opts.Type
	}

	if opts.Value != "" {
		params["content"] = opts.Value
	}

	if opts.Ttl != "" {
		ttl, err := strconv.ParseInt(opts.Ttl, 0, 0)
		if err != nil {
			return "", nil
		}
		params["ttl"] = ttl
	}

	endpoint := fmt.Sprintf("/domains/%s/records/%s", domain, id)

	req, err := c.NewRequest(params, "PUT", endpoint)
	if err != nil {
		return "", err
	}

	resp, err := checkResp(c.Http.Do(req))
	if err != nil {
		return "", fmt.Errorf("Error updating record: %s", err)
	}

	record := new(RecordResponse)

	err = decodeBody(resp, &record)

	if err != nil {
		return "", fmt.Errorf("Error parsing record response: %s", err)
	}

	// The request was successful
	return record.Record.StringId(), nil
}

// DestroyRecord destroys a record by the ID specified and
// returns an error if it fails. If no error is returned,
// the Record was succesfully destroyed.
func (c *Client) DestroyRecord(domain string, id string) error {
	var body map[string]interface{}
	req, err := c.NewRequest(body, "DELETE", fmt.Sprintf("/domains/%s/records/%s", domain, id))

	if err != nil {
		return err
	}

	_, err = checkResp(c.Http.Do(req))

	if err != nil {
		return fmt.Errorf("Error destroying record: %s", err)
	}

	// The request was successful
	return nil
}

// RetrieveRecord gets  a record by the ID specified and
// returns a Record and an error. An error will be returned for failed
// requests with a nil Record.
func (c *Client) RetrieveRecord(domain string, id string) (*Record, error) {
	var body map[string]interface{}
	req, err := c.NewRequest(body, "GET", fmt.Sprintf("/domains/%s/records/%s", domain, id))
	if err != nil {
		return nil, err
	}

	resp, err := checkResp(c.Http.Do(req))
	if err != nil {
		return nil, fmt.Errorf("Error retrieving record: %s", err)
	}

	recordResp := RecordResponse{}

	err = decodeBody(resp, &recordResp)

	if err != nil {
		return nil, fmt.Errorf("Error decoding record response: %s", err)
	}

	// The request was successful
	return &recordResp.Record, nil
}

// GetRecords retrieves all the records for the given domain.
func (c *Client) GetRecords(domain string) ([]Record, error) {
	req, err := c.NewRequest(nil, "GET", "/domains/"+domain+"/records")
	if err != nil {
		return nil, err
	}
	resp, err := c.Http.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	recordResponses := make([]RecordResponse, 10)
	err = decode(resp.Body, &recordResponses)
	if err != nil {
		return nil, err
	}
	records := make([]Record, len(recordResponses))
	for i, rr := range recordResponses {
		records[i] = rr.Record
	}
	return records, nil
}


text:
(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('chart.js'), require('moment')) :
	typeof define === 'function' && define.amd ? define(['chart.js', 'moment'], factory) :
	(global['chartjs-plugin-streaming'] = factory(global.Chart,global.moment));
}(this, (function (Chart,moment) { 'use strict';

Chart = Chart && Chart.hasOwnProperty('default') ? Chart['default'] : Chart;
moment = moment && moment.hasOwnProperty('default') ? moment['default'] : moment;

'use strict';

var helpers = Chart.helpers;

helpers.cancelAnimFrame = (function() {
	if (typeof window !== 'undefined') {
		return window.cancelAnimationFrame ||
			window.webkitCancelAnimationFrame ||
			window.mozCancelAnimationFrame ||
			window.oCancelAnimationFrame ||
			window.msCancelAnimationFrame ||
			function(id) {
				return window.clearTimeout(id);
			};
	}
}());

helpers.startFrameRefreshTimer = function(context, func) {
	if (!context.frameRequestID) {
		var frameRefresh = function() {
			func();
			context.frameRequestID = helpers.requestAnimFrame.call(window, frameRefresh);
		};
		context.frameRequestID = helpers.requestAnimFrame.call(window, frameRefresh);
	}
};

helpers.stopFrameRefreshTimer = function(context) {
	var frameRequestID = context.frameRequestID;

	if (frameRequestID) {
		helpers.cancelAnimFrame.call(window, frameRequestID);
		delete context.frameRequestID;
	}
};

'use strict';

var scaleService = Chart.scaleService;
var TimeScale = scaleService.getScaleConstructor('time');

scaleService.getScaleConstructor = function(type) {
	// For backwards compatibility
	if (type === 'time') {
		type = 'realtime';
	}
	return this.constructors.hasOwnProperty(type) ? this.constructors[type] : undefined;
};

// Ported from Chart.js 2.7.3 1cd0469.
var MAX_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;

// Ported from Chart.js 2.7.3 1cd0469.
var INTERVALS = {
	millisecond: {
		common: true,
		size: 1,
		steps: [1, 2, 5, 10, 20, 50, 100, 250, 500]
	},
	second: {
		common: true,
		size: 1000,
		steps: [1, 2, 5, 10, 15, 30]
	},
	minute: {
		common: true,
		size: 60000,
		steps: [1, 2, 5, 10, 15, 30]
	},
	hour: {
		common: true,
		size: 3600000,
		steps: [1, 2, 3, 6, 12]
	},
	day: {
		common: true,
		size: 86400000,
		steps: [1, 2, 5]
	},
	week: {
		common: false,
		size: 604800000,
		steps: [1, 2, 3, 4]
	},
	month: {
		common: true,
		size: 2.628e9,
		steps: [1, 2, 3]
	},
	quarter: {
		common: false,
		size: 7.884e9,
		steps: [1, 2, 3, 4]
	},
	year: {
		common: true,
		size: 3.154e10
	}
};

// Ported from Chart.js 2.7.3 1cd0469.
var UNITS = Object.keys(INTERVALS);

// Ported from Chart.js 2.7.3 1cd0469.
function momentify(value, options) {
	var parser = options.parser;
	var format = options.parser || options.format;

	if (typeof parser === 'function') {
		return parser(value);
	}

	if (typeof value === 'string' && typeof format === 'string') {
		return moment(value, format);
	}

	if (!(value instanceof moment)) {
		value = moment(value);
	}

	if (value.isValid()) {
		return value;
	}

	// Labels are in an incompatible moment format and no `parser` has been provided.
	// The user might still use the deprecated `format` option to convert his inputs.
	if (typeof format === 'function') {
		return format(value);
	}

	return value;
}

// Ported from Chart.js 2.7.3 1cd0469.
function parse(input, scale) {
	if (helpers.isNullOrUndef(input)) {
		return null;
	}

	var options = scale.options.time;
	var value = momentify(scale.getRightValue(input), options);
	if (!value.isValid()) {
		return null;
	}

	if (options.round) {
		value.startOf(options.round);
	}

	return value.valueOf();
}

// Ported from Chart.js 2.7.3 1cd0469.
function determineStepSize(min, max, unit, capacity) {
	var range = max - min;
	var interval = INTERVALS[unit];
	var milliseconds = interval.size;
	var steps = interval.steps;
	var i, ilen, factor;

	if (!steps) {
		return Math.ceil(range / (capacity * milliseconds));
	}

	for (i = 0, ilen = steps.length; i < ilen; ++i) {
		factor = steps[i];
		if (Math.ceil(range / (milliseconds * factor)) <= capacity) {
			break;
		}
	}

	return factor;
}

// Ported from Chart.js 2.7.3 1cd0469.
function determineUnitForAutoTicks(minUnit, min, max, capacity) {
	var ilen = UNITS.length;
	var i, interval, factor;

	for (i = UNITS.indexOf(minUnit); i < ilen - 1; ++i) {
		interval = INTERVALS[UNITS[i]];
		factor = interval.steps ? interval.steps[interval.steps.length - 1] : MAX_INTEGER;

		if (interval.common && Math.ceil((max - min) / (factor * interval.size)) <= capacity) {
			return UNITS[i];
		}
	}

	return UNITS[ilen - 1];
}

// Ported from Chart.js 2.7.3 1cd0469.
function determineUnitForFormatting(ticks, minUnit, min, max) {
	var duration = moment.duration(moment(max).diff(moment(min)));
	var ilen = UNITS.length;
	var i, unit;

	for (i = ilen - 1; i >= UNITS.indexOf(minUnit); i--) {
		unit = UNITS[i];
		if (INTERVALS[unit].common && duration.as(unit) >= ticks.length) {
			return unit;
		}
	}

	return UNITS[minUnit ? UNITS.indexOf(minUnit) : 0];
}

// Ported from Chart.js 2.7.3 1cd0469.
function determineMajorUnit(unit) {
	for (var i = UNITS.indexOf(unit) + 1, ilen = UNITS.length; i < ilen; ++i) {
		if (INTERVALS[UNITS[i]].common) {
			return UNITS[i];
		}
	}
}

// Ported from Chart.js 2.7.3 1cd0469. Modified for realtime scale.
function generate(min, max, capacity, options, refresh) {
	var timeOpts = options.time;
	var minor = timeOpts.unit || determineUnitForAutoTicks(timeOpts.minUnit, min, max, capacity);
	var major = determineMajorUnit(minor);
	var stepSize = helpers.valueOrDefault(timeOpts.stepSize, timeOpts.unitStepSize);
	var weekday = minor === 'week' ? timeOpts.isoWeekday : false;
	// For realtime scale: Major ticks are always enabled.
	var majorTicksEnabled = true;
	var interval = INTERVALS[minor];
	var first = moment(min);
	// For realtime scale: Add refresh interval for scroll margin.
	var last = moment(max + refresh);
	var ticks = [];
	var time;

	if (!stepSize) {
		stepSize = determineStepSize(min, max, minor, capacity);
	}

	// For 'week' unit, handle the first day of week option
	if (weekday) {
		first = first.isoWeekday(weekday);
		last = last.isoWeekday(weekday);
	}

	// Align first/last ticks on unit
	first = first.startOf(weekday ? 'day' : minor);
	last = last.startOf(weekday ? 'day' : minor);

	// Make sure that the last tick include max
	if (last < max + refresh) {
		last.add(1, minor);
	}

	time = moment(first);

	if (majorTicksEnabled && major && !weekday && !timeOpts.round) {
		// Align the first tick on the previous `minor` unit aligned on the `major` unit:
		// we first aligned time on the previous `major` unit then add the number of full
		// stepSize there is between first and the previous major time.
		time.startOf(major);
		time.add(~~((first - time) / (interval.size * stepSize)) * stepSize, minor);
	}

	for (; time < last; time.add(stepSize, minor)) {
		ticks.push(+time);
	}

	ticks.push(+time);

	return ticks;
}

// Ported from Chart.js 2.7.3 1cd0469.
function ticksFromTimestamps(values, majorUnit) {
	var ticks = [];
	var i, ilen, value, major;

	for (i = 0, ilen = values.length; i < ilen; ++i) {
		value = values[i];
		major = majorUnit ? value === +moment(value).startOf(majorUnit) : false;

		ticks.push({
			value: value,
			major: major
		});
	}

	return ticks;
}

// Ported from Chart.js 2.7.3 1cd0469.
function determineLabelFormat(data, timeOpts) {
	var i, momentDate, hasTime;
	var ilen = data.length;

	// find the label with the most parts (milliseconds, minutes, etc.)
	// format all labels with the same level of detail as the most specific label
	for (i = 0; i < ilen; i++) {
		momentDate = momentify(data[i], timeOpts);
		if (momentDate.millisecond() !== 0) {
			return 'MMM D, YYYY h:mm:ss.SSS a';
		}
		if (momentDate.second() !== 0 || momentDate.minute() !== 0 || momentDate.hour() !== 0) {
			hasTime = true;
		}
	}
	if (hasTime) {
		return 'MMM D, YYYY h:mm:ss a';
	}
	return 'MMM D, YYYY';
}

function resolveOption(scale, key) {
	var realtimeOpts = scale.options.realtime;
	var streamingOpts = scale.chart.options.plugins.streaming;
	return helpers.valueOrDefault(realtimeOpts[key], streamingOpts[key]);
}

var datasetPropertyKeys = [
	'pointBackgroundColor',
	'pointBorderColor',
	'pointBorderWidth',
	'pointRadius',
	'pointStyle',
	'pointHitRadius',
	'pointHoverBackgroundColor',
	'pointHoverBorderColor',
	'pointHoverBorderWidth',
	'pointHoverRadius',
	'backgroundColor',
	'borderColor',
	'borderWidth',
	'hoverBackgroundColor',
	'hoverBorderColor',
	'hoverBorderWidth',
	'hoverRadius',
	'hitRadius',
	'radius'
];

function refreshData(scale) {
	var chart = scale.chart;
	var id = scale.id;
	var duration = resolveOption(scale, 'duration');
	var delay = resolveOption(scale, 'delay');
	var ttl = resolveOption(scale, 'ttl');
	var pause = resolveOption(scale, 'pause');
	var onRefresh = resolveOption(scale, 'onRefresh');
	var max = scale.max;
	var min = Date.now() - (isNaN(ttl) ? duration + delay : ttl);
	var meta, data, length, i, start, count, removalRange;

	if (onRefresh) {
		onRefresh(chart);
	}

	// Remove old data
	chart.data.datasets.forEach(function(dataset, datasetIndex) {
		meta = chart.getDatasetMeta(datasetIndex);
		if (id === meta.xAxisID || id === meta.yAxisID) {
			data = dataset.data;
			length = data.length;

			if (pause) {
				// If the scale is paused, preserve the visible data points
				for (i = 0; i < length; ++i) {
					if (!(scale._getTimeForIndex(i, datasetIndex) < max)) {
						break;
					}
				}
				start = i + 2;
			} else {
				start = 0;
			}

			for (i = start; i < length; ++i) {
				if (!(scale._getTimeForIndex(i, datasetIndex) <= min)) {
					break;
				}
			}
			count = i - start;
			if (isNaN(ttl)) {
				// Keep the last two data points outside the range not to affect the existing bezier curve
				count = Math.max(count - 2, 0);
			}

			data.splice(start, count);
			datasetPropertyKeys.forEach(function(key) {
				if (dataset.hasOwnProperty(key) && helpers.isArray(dataset[key])) {
					dataset[key].splice(start, count);
				}
			});
			if (typeof data[0] !== 'object') {
				removalRange = {
					start: start,
					count: count
				};
			}
		}
	});
	if (removalRange) {
		chart.data.labels.splice(removalRange.start, removalRange.count);
	}

	chart.update({
		preservation: true
	});
}

function stopDataRefreshTimer(scale) {
	var realtime = scale.realtime;
	var refreshTimerID = realtime.refreshTimerID;

	if (refreshTimerID) {
		clearInterval(refreshTimerID);
		delete realtime.refreshTimerID;
		delete realtime.refreshInterval;
	}
}

function startDataRefreshTimer(scale) {
	var realtime = scale.realtime;
	var interval = resolveOption(scale, 'refresh');

	realtime.refreshTimerID = setInterval(function() {
		var newInterval = resolveOption(scale, 'refresh');

		refreshData(scale);
		if (realtime.refreshInterval !== newInterval && !isNaN(newInterval)) {
			stopDataRefreshTimer(scale);
			startDataRefreshTimer(scale);
		}
	}, interval);
	realtime.refreshInterval = interval;
}

var transitionKeys = {
	x: {
		data: ['x', 'controlPointPreviousX', 'controlPointNextX'],
		dataset: ['x'],
		tooltip: ['x', 'caretX']
	},
	y: {
		data: ['y', 'controlPointPreviousY', 'controlPointNextY'],
		dataset: ['y'],
		tooltip: ['y', 'caretY']
	}
};

function transition(element, keys, translate) {
	var start = element._start || {};
	var view = element._view || {};
	var model = element._model || {};
	var i, ilen;

	for (i = 0, ilen = keys.length; i < ilen; ++i) {
		var key = keys[i];
		if (start.hasOwnProperty(key)) {
			start[key] -= translate;
		}
		if (view.hasOwnProperty(key) && view !== start) {
			view[key] -= translate;
		}
		if (model.hasOwnProperty(key) && model !== view) {
			model[key] -= translate;
		}
	}
}

function scroll(scale) {
	var chart = scale.chart;
	var realtime = scale.realtime;
	var duration = resolveOption(scale, 'duration');
	var delay = resolveOption(scale, 'delay');
	var id = scale.id;
	var tooltip = chart.tooltip;
	var activeTooltip = tooltip._active;
	var now = Date.now();
	var length, keys, offset, meta, elements, i, ilen;

	if (scale.isHorizontal()) {
		length = scale.width;
		keys = transitionKeys.x;
	} else {
		length = scale.height;
		keys = transitionKeys.y;
	}
	offset = length * (now - realtime.head) / duration;

	// Shift all the elements leftward or upward
	helpers.each(chart.data.datasets, function(dataset, datasetIndex) {
		meta = chart.getDatasetMeta(datasetIndex);
		if (id === meta.xAxisID || id === meta.yAxisID) {
			elements = meta.data || [];

			for (i = 0, ilen = elements.length; i < ilen; ++i) {
				transition(elements[i], keys.data, offset);
			}

			if (meta.dataset) {
				transition(meta.dataset, keys.dataset, offset);
			}
		}
	});

	// Shift tooltip leftward or upward
	if (activeTooltip && activeTooltip[0]) {
		meta = chart.getDatasetMeta(activeTooltip[0]._datasetIndex);
		if (id === meta.xAxisID || id === meta.yAxisID) {
			transition(tooltip, keys.tooltip, offset);
		}
	}

	scale.max = scale._table[1].time = now - delay;
	scale.min = scale._table[0].time = scale.max - duration;

	realtime.head = now;
}

var defaultConfig = {
	position: 'bottom',
	distribution: 'linear',
	bounds: 'data',

	time: {
		parser: false, // false == a pattern string from http://momentjs.com/docs/#/parsing/string-format/ or a custom callback that converts its argument to a moment
		format: false, // DEPRECATED false == date objects, moment object, callback or a pattern string from http://momentjs.com/docs/#/parsing/string-format/
		unit: false, // false == automatic or override with week, month, year, etc.
		round: false, // none, or override with week, month, year, etc.
		displayFormat: false, // DEPRECATED
		isoWeekday: false, // override week start day - see http://momentjs.com/docs/#/get-set/iso-weekday/
		minUnit: 'millisecond',

		// defaults to unit's corresponding unitFormat below or override using pattern string from http://momentjs.com/docs/#/displaying/format/
		displayFormats: {
			millisecond: 'h:mm:ss.SSS a', // 11:20:01.123 AM,
			second: 'h:mm:ss a', // 11:20:01 AM
			minute: 'h:mm a', // 11:20 AM
			hour: 'hA', // 5PM
			day: 'MMM D', // Sep 4
			week: 'll', // Week 46, or maybe "[W]WW - YYYY" ?
			month: 'MMM YYYY', // Sept 2015
			quarter: '[Q]Q - YYYY', // Q3
			year: 'YYYY' // 2015
		},
	},
	realtime: {},
	ticks: {
		autoSkip: false,
		source: 'auto',
		major: {
			enabled: true
		}
	}
};

var RealTimeScale = TimeScale.extend({
	initialize: function() {
		var me = this;

		TimeScale.prototype.initialize.apply(me, arguments);

		// For backwards compatibility
		if (me.options.type === 'time' && !me.chart.options.plugins.streaming) {
			return;
		}

		me.realtime = me.realtime || {};

		startDataRefreshTimer(me);
	},

	update: function() {
		var me = this;
		var realtime = me.realtime;

		// For backwards compatibility
		if (me.options.type === 'time' && !me.chart.options.plugins.streaming) {
			return TimeScale.prototype.update.apply(me, arguments);
		}

		if (resolveOption(me, 'pause')) {
			helpers.stopFrameRefreshTimer(realtime);
		} else {
			helpers.startFrameRefreshTimer(realtime, function() {
				scroll(me);
			});
			realtime.head = Date.now();
		}

		return TimeScale.prototype.update.apply(me, arguments);
	},

	buildTicks: function() {
		var me = this;
		var options = me.options;

		// For backwards compatibility
		if (options.type === 'time' && !me.chart.options.plugins.streaming) {
			return TimeScale.prototype.buildTicks.apply(me, arguments);
		}

		var timeOpts = options.time;
		var duration = resolveOption(me, 'duration');
		var delay = resolveOption(me, 'delay');
		var refresh = resolveOption(me, 'refresh');
		var max = me.realtime.head - delay;
		var min = max - duration;
		var timestamps = [];

		switch (options.ticks.source) {
		case 'data':
			timestamps = me._timestamps.data;
			break;
		case 'labels':
			timestamps = me._timestamps.labels;
			break;
		case 'auto':
		default:
			timestamps = generate(min, max, me.getLabelCapacity(min), options, refresh);
		}

		me.min = min;
		me.max = max;

		// PRIVATE
		me._unit = timeOpts.unit || determineUnitForFormatting(timestamps, timeOpts.minUnit, me.min, me.max);
		me._majorUnit = determineMajorUnit(me._unit);
		// realtime scale only supports linear distribution.
		me._table = [{time: min, pos: 0}, {time: max, pos: 1}];
		// offset is always disabled.
		me._offsets = {left: 0, right: 0};
		me._labelFormat = determineLabelFormat(me._timestamps.data, timeOpts);

		return ticksFromTimestamps(timestamps, me._majorUnit);
	},

	fit: function() {
		var me = this;
		var options = me.options;

		TimeScale.prototype.fit.apply(me, arguments);

		// For backwards compatibility
		if (options.type === 'time' && !me.chart.options.plugins.streaming) {
			return;
		}

		if (options.ticks.display && options.display && me.isHorizontal()) {
			me.paddingLeft = 3;
			me.paddingRight = 3;
			me.handleMargins();
		}
	},

	draw: function(chartArea) {
		var me = this;
		var chart = me.chart;

		// For backwards compatibility
		if (me.options.type === 'time' && !chart.options.plugins.streaming) {
			TimeScale.prototype.draw.apply(me, arguments);
			return;
		}

		var context = me.ctx;
		var	clipArea = me.isHorizontal() ?
			{
				left: chartArea.left,
				top: 0,
				right: chartArea.right,
				bottom: chart.height
			} : {
				left: 0,
				top: chartArea.top,
				right: chart.width,
				bottom: chartArea.bottom
			};

		// Clip and draw the scale
		helpers.canvas.clipArea(context, clipArea);
		TimeScale.prototype.draw.apply(me, arguments);
		helpers.canvas.unclipArea(context);
	},

	destroy: function() {
		var me = this;

		// For backwards compatibility
		if (me.options.type === 'time' && !me.chart.options.plugins.streaming) {
			return;
		}

		helpers.stopFrameRefreshTimer(me.realtime);
		stopDataRefreshTimer(me);
	},

	/*
	 * @private
	 */
	_getTimeForIndex: function(index, datasetIndex) {
		var me = this;
		var timestamps = me._timestamps;
		var time = timestamps.datasets[datasetIndex][index];
		var value;

		if (helpers.isNullOrUndef(time)) {
			value = me.chart.data.datasets[datasetIndex].data[index];
			if (helpers.isObject(value)) {
				time = parse(me.getRightValue(value), me);
			} else {
				time = parse(timestamps.labels[index], me);
			}
		}

		return time;
	}
});

scaleService.registerScaleType('realtime', RealTimeScale, defaultConfig);

'use strict';

Chart.defaults.global.plugins.streaming = {
	duration: 10000,
	delay: 0,
	frameRate: 30,
	refresh: 1000,
	onRefresh: null,
	pause: false,
	ttl: undefined
};

// Dispach mouse event for scroll
function generateMouseMoveEvent(chart) {
	var event = chart.streaming.lastMouseEvent;
	var newEvent;

	if (event) {
		if (typeof MouseEvent === 'function') {
			newEvent = new MouseEvent('mousemove', event);
		} else {
			newEvent = document.createEvent('MouseEvents');
			newEvent.initMouseEvent(
				'mousemove', event.bubbles, event.cancelable, event.view, event.detail,
				event.screenX, event.screenY, event.clientX, event.clientY, event.ctrlKey,
				event.altKey, event.shiftKey, event.metaKey, event.button, event.relatedTarget
			);
		}
		chart.canvas.dispatchEvent(newEvent);
	}
}

/**
 * Update the chart data keeping the current animation but suppressing a new one
 * @param chart {Chart} chart to update
 */
function updateChartData(chart) {
	var animationOpts = chart.options.animation;
	var datasets = chart.data.datasets;
	var newControllers = chart.buildOrUpdateControllers();

	datasets.forEach(function(dataset, datasetIndex) {
		chart.getDatasetMeta(datasetIndex).controller.buildOrUpdateElements();
	});
	chart.updateLayout();
	if (animationOpts && animationOpts.duration) {
		helpers.each(newControllers, function(controller) {
			controller.reset();
		});
	}
	chart.updateDatasets();

	if (chart.animating) {
		// If the chart is animating, keep it until the duration is over
		Chart.animationService.animations.forEach(function(animation) {
			if (animation.chart === chart) {
				chart.render({
					duration: (animation.numSteps - animation.currentStep) * 16.66
				});
			}
		});
	} else {
		// If the chart is not animating, make sure that all elements are at the final positions
		datasets.forEach(function(dataset, datasetIndex) {
			chart.getDatasetMeta(datasetIndex).controller.transition(1);
		});
	}

	if (chart.tooltip._active) {
		chart.tooltip.update(true);
	}

	generateMouseMoveEvent(chart);
}

var update = Chart.prototype.update;

Chart.prototype.update = function(config) {
	if (config && config.preservation) {
		updateChartData(this);
	} else {
		update.apply(this, arguments);
	}
};

// Draw chart at frameRate
function drawChart(chart) {
	var streaming = chart.streaming;
	var frameRate = chart.options.plugins.streaming.frameRate;
	var frameDuration = 1000 / (Math.max(frameRate, 0) || 30);
	var next = streaming.lastDrawn + frameDuration || 0;
	var now = Date.now();

	if (next <= now) {
		// Draw only when animation is inactive
		if (!chart.animating && !chart.tooltip._start) {
			chart.draw();
		}
		generateMouseMoveEvent(chart);
		streaming.lastDrawn = (next + frameDuration > now) ? next : now;
	}
}

var streamingPlugin$1 = {
	id: 'streaming',

	beforeInit: function(chart) {
		var streaming = chart.streaming = chart.streaming || {};
		var canvas = streaming.canvas = chart.canvas;
		var mouseEventListener = streaming.mouseEventListener = function(event) {
			streaming.lastMouseEvent = event;
		};

		canvas.addEventListener('mousedown', mouseEventListener);
		canvas.addEventListener('mouseup', mouseEventListener);
	},

	afterInit: function(chart) {
		if (chart.resetZoom) {
			Chart.Zoom.updateResetZoom(chart);
		}
	},

	beforeUpdate: function(chart) {
		var chartOpts = chart.options;
		var scalesOpts = chartOpts.scales;

		if (scalesOpts) {
			scalesOpts.xAxes.concat(scalesOpts.yAxes).forEach(function(scaleOpts) {
				if (scaleOpts.type === 'realtime' || scaleOpts.type === 'time') {
					// Allow Bézier control to be outside the chart
					chartOpts.elements.line.capBezierPoints = false;
				}
			});
		}
		return true;
	},

	afterUpdate: function(chart, options) {
		var streaming = chart.streaming;
		var pause = true;

		// if all scales are paused, stop refreshing frames
		helpers.each(chart.scales, function(scale) {
			if (scale instanceof RealTimeScale) {
				pause &= helpers.valueOrDefault(scale.options.realtime.pause, options.pause);
			}
		});
		if (pause) {
			helpers.stopFrameRefreshTimer(streaming);
		} else {
			helpers.startFrameRefreshTimer(streaming, function() {
				drawChart(chart);
			});
		}
	},

	beforeDatasetDraw: function(chart, args) {
		var meta = args.meta;
		var chartArea = chart.chartArea;
		var clipArea = {
			left: 0,
			top: 0,
			right: chart.width,
			bottom: chart.height
		};
		if (meta.xAxisID && meta.controller.getScaleForId(meta.xAxisID) instanceof RealTimeScale) {
			clipArea.left = chartArea.left;
			clipArea.right = chartArea.right;
		}
		if (meta.yAxisID && meta.controller.getScaleForId(meta.yAxisID) instanceof RealTimeScale) {
			clipArea.top = chartArea.top;
			clipArea.bottom = chartArea.bottom;
		}
		helpers.canvas.clipArea(chart.ctx, clipArea);
		return true;
	},

	afterDatasetDraw: function(chart) {
		helpers.canvas.unclipArea(chart.ctx);
	},

	beforeEvent: function(chart, event) {
		var streaming = chart.streaming;

		if (event.type === 'mousemove') {
			// Save mousemove event for reuse
			streaming.lastMouseEvent = event.native;
		} else if (event.type === 'mouseout') {
			// Remove mousemove event
			delete streaming.lastMouseEvent;
		}
		return true;
	},

	destroy: function(chart) {
		var streaming = chart.streaming;
		var canvas = streaming.canvas;
		var mouseEventListener = streaming.mouseEventListener;

		helpers.stopFrameRefreshTimer(streaming);

		canvas.removeEventListener('mousedown', mouseEventListener);
		canvas.removeEventListener('mouseup', mouseEventListener);

		helpers.each(chart.scales, function(scale) {
			if (scale instanceof RealTimeScale) {
				scale.destroy();
			}
		});
	}
};

'use strict';

// Ported from chartjs-plugin-zoom 0.6.6 b0c3b20
var zoomNS = Chart.Zoom = Chart.Zoom || {};

// Ported from chartjs-plugin-zoom 0.6.6 b0c3b20
zoomNS.zoomFunctions = zoomNS.zoomFunctions || {};
zoomNS.panFunctions = zoomNS.panFunctions || {};

// Ported from chartjs-plugin-zoom 0.6.6 b0c3b20
function rangeMaxLimiter(zoomPanOptions, newMax) {
	if (zoomPanOptions.scaleAxes && zoomPanOptions.rangeMax &&
			!helpers.isNullOrUndef(zoomPanOptions.rangeMax[zoomPanOptions.scaleAxes])) {
		var rangeMax = zoomPanOptions.rangeMax[zoomPanOptions.scaleAxes];
		if (newMax > rangeMax) {
			newMax = rangeMax;
		}
	}
	return newMax;
}

// Ported from chartjs-plugin-zoom 0.6.6 b0c3b20
function rangeMinLimiter(zoomPanOptions, newMin) {
	if (zoomPanOptions.scaleAxes && zoomPanOptions.rangeMin &&
			!helpers.isNullOrUndef(zoomPanOptions.rangeMin[zoomPanOptions.scaleAxes])) {
		var rangeMin = zoomPanOptions.rangeMin[zoomPanOptions.scaleAxes];
		if (newMin < rangeMin) {
			newMin = rangeMin;
		}
	}
	return newMin;
}

function zoomRealTimeScale(scale, zoom, center, zoomOptions) {
	var realtimeOpts = scale.options.realtime;
	var streamingOpts = scale.chart.options.plugins.streaming;
	var duration = helpers.valueOrDefault(realtimeOpts.duration, streamingOpts.duration);
	var delay = helpers.valueOrDefault(realtimeOpts.delay, streamingOpts.delay);
	var newDuration = duration * (2 - zoom);
	var maxPercent, limitedDuration;

	if (scale.isHorizontal()) {
		maxPercent = (scale.right - center.x) / (scale.right - scale.left);
	} else {
		maxPercent = (scale.bottom - center.y) / (scale.bottom - scale.top);
	}
	if (zoom < 1) {
		limitedDuration = rangeMaxLimiter(zoomOptions, newDuration);
	} else {
		limitedDuration = rangeMinLimiter(zoomOptions, newDuration);
	}
	realtimeOpts.duration = limitedDuration;
	realtimeOpts.delay = delay + maxPercent * (duration - limitedDuration);
}

function panRealTimeScale(scale, delta, panOptions) {
	var realtimeOpts = scale.options.realtime;
	var streamingOpts = scale.chart.options.plugins.streaming;
	var delay = helpers.valueOrDefault(realtimeOpts.delay, streamingOpts.delay);
	var newDelay = delay + (scale.getValueForPixel(delta) - scale.getValueForPixel(0));

	if (delta > 0) {
		realtimeOpts.delay = rangeMaxLimiter(panOptions, newDelay);
	} else {
		realtimeOpts.delay = rangeMinLimiter(panOptions, newDelay);
	}
}

zoomNS.zoomFunctions.realtime = zoomRealTimeScale;
zoomNS.panFunctions.realtime = panRealTimeScale;

function updateResetZoom(chart) {
	chart.resetZoom = function() {
		helpers.each(chart.scales, function(scale) {
			var timeOptions = scale.options.time;
			var realtimeOptions = scale.options.realtime;
			var tickOptions = scale.options.ticks;

			if (timeOptions) {
				timeOptions.min = scale.originalOptions.time.min;
				timeOptions.max = scale.originalOptions.time.max;
			}

			if (realtimeOptions) {
				realtimeOptions.duration = scale.originalOptions.realtime.duration;
				realtimeOptions.delay = scale.originalOptions.realtime.delay;
			}

			if (tickOptions) {
				tickOptions.min = scale.originalOptions.ticks.min;
				tickOptions.max = scale.originalOptions.ticks.max;
			}
		});

		chart.update({
			duration: 0
		});
	};
}

zoomNS.updateResetZoom = updateResetZoom;

'use strict';

Chart.plugins.register(streamingPlugin$1);

return streamingPlugin$1;

})));


text:
package com.github.kennycyb.uifactory.sample.panel;

/**
 *
 * @since 1.0
 */
public class CustomEventArgs {

	private final ExternalPanel mSource;
	private final String mMessage;

	public CustomEventArgs(ExternalPanel source, String message) {
		mSource = source;
		mMessage = message;
	}

	public ExternalPanel getSource() {
		return mSource;
	}

	public String getMessage() {
		return mMessage;
	}
}


text: Static template named 'bar.html'


text:
#pragma once
#include <aws/schemas/Schemas_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>

namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace Schemas
{
namespace Model
{

  class AWS_SCHEMAS_API ConflictException
  {
  public:
    ConflictException();
    ConflictException(Aws::Utils::Json::JsonView jsonValue);
    ConflictException& operator=(Aws::Utils::Json::JsonView jsonValue);
    Aws::Utils::Json::JsonValue Jsonize() const;

    /**
     *
The error code.

     */
    inline const Aws::String& GetCode() const{ return m_code; }

    /**
     *
The error code.

     */
    inline bool CodeHasBeenSet() const { return m_codeHasBeenSet; }

    /**
     *
The error code.

     */
    inline void SetCode(const Aws::String& value) { m_codeHasBeenSet = true; m_code = value; }

    /**
     *
The error code.

     */
    inline void SetCode(Aws::String&& value) { m_codeHasBeenSet = true; m_code = std::move(value); }

    /**
     *
The error code.

     */
    inline void SetCode(const char* value) { m_codeHasBeenSet = true; m_code.assign(value); }

    /**
     *
The error code.

     */
    inline ConflictException& WithCode(const Aws::String& value) { SetCode(value); return *this;}

    /**
     *
The error code.

     */
    inline ConflictException& WithCode(Aws::String&& value) { SetCode(std::move(value)); return *this;}

    /**
     *
The error code.

     */
    inline ConflictException& WithCode(const char* value) { SetCode(value); return *this;}

    /**
     *
The message string of the error output.

     */
    inline const Aws::String& GetMessage() const{ return m_message; }

    /**
     *
The message string of the error output.

     */
    inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }

    /**
     *
The message string of the error output.

     */
    inline void SetMessage(const Aws::String& value) { m_messageHasBeenSet = true; m_message = value; }

    /**
     *
The message string of the error output.

     */
    inline void SetMessage(Aws::String&& value) { m_messageHasBeenSet = true; m_message = std::move(value); }

    /**
     *
The message string of the error output.

     */
    inline void SetMessage(const char* value) { m_messageHasBeenSet = true; m_message.assign(value); }

    /**
     *
The message string of the error output.

     */
    inline ConflictException& WithMessage(const Aws::String& value) { SetMessage(value); return *this;}

    /**
     *
The message string of the error output.

     */
    inline ConflictException& WithMessage(Aws::String&& value) { SetMessage(std::move(value)); return *this;}

    /**
     *
The message string of the error output.

     */
    inline ConflictException& WithMessage(const char* value) { SetMessage(value); return *this;}

  private:

    Aws::String m_code;
    bool m_codeHasBeenSet;

    Aws::String m_message;
    bool m_messageHasBeenSet;
  };

} // namespace Model
} // namespace Schemas
} // namespace Aws


text:
const path = require('path')
const fs = require('fs')
const htmlPrivateArea = fs.readFileSync(path.join(__dirname, '/template.html'), 'utf-8')

function privateAreaConfig ($routeProvider) {
  $routeProvider
    .when('/username/:id', {
      template: htmlPrivateArea,
      controller: 'privateAreaController'
    })
}

module.exports = privateAreaConfig


text:
<template name="badges">

Badges

Give
		<select class="btn btn-sm">
			<option>BinaryBrain</option>
			<option>D34D70CK</option>
			<option>Wasadigi</option>
		</select>
		the badge
		<select class="btn btn-sm">
			<option>Newbie</option>
			<option>Cool Bro</option>
		</select>
		<input class="btn btn-primary btn-sm" type="submit">

</template>


text:
require "goggles/configuration"
require "goggles/comparison"
require "goggles/iteration"

module Goggles
  extend self

  #
  # Raise when the configuration attribute is unconfigured at runtime.
  #
  class EmptyDirectoryError < StandardError; end

  #
  # Yields the global configuration object to a block.
  #
  # @yield  [Goggles::Configuration] global configuration
  # @return [Goggles::Configuration] global configuration
  #
  def configure &block
    configuration.tap { |conf| yield conf }
  end

  #
  # Creates an Iteration object for each combination of browser and width derived from global
  #  configuration and given arguments.
  #
  # @param instance [Array<String,Fixnum,Symbol>, String, Fixnum, Symbol] configuration extension
  # @return [Goggles::Comparison]
  # @see Goggles::Iteration
  #
  def each *instance, &block
    validate_directory_setting
    args = instance.flatten.map(&:to_s)

    sizes = configuration.sizes + args.grep(/\d+/).map(&:to_i)
    browsers = configuration.browsers + args.grep(/[^\d+]/).map(&:to_sym)

    browsers.product(sizes).each do |browser, size|
      Iteration.new browser, size, configuration, &block
    end

    Comparison.new(configuration).tap { |comparison| comparison.make! }
  end

  private

  #
  # @api private
  #
  def configuration
    @configuration ||= Configuration.new
  end

  #
  # @api private
  #
  def validate_directory_setting
    message = "Expected configured directory setting, got: #{configuration.directory}"
    raise EmptyDirectoryError, message if configuration.directory.nil?
    raise EmptyDirectoryError, message if configuration.directory.empty?
  end
end


text:
require 'rubygems'
require 'bud'
require 'chord/chord_find'
require 'chord/chord_node'

# support multiple successors per node.
# this is independent of whether you use ChordStable or ChordJoin
module ChordSuccessors
  import ChordSuccPred => :sp2

  state do
    table   :successors, [:index] => [:start, :addr, :dist]
    scratch :mos, successors.schema
    scratch :min_successor, successors.schema
    table   :succ_pred_pending, [:addr, :timestep, :hops]
    scratch :succ_pred_dist, [:from, :dist, :start, :pred_id, :pred_addr]
    periodic :succ_timer, 2
  end

  bloom :stabilize_successors do
    # ask successor for a bunch of successor_predecessors
    temp :spr <= succ_timer do |t|
      [finger[[0]].succ_addr, ip_port, log2(@maxkey)] unless finger[[0]].nil? or finger[[0]].succ_addr.nil?
    end
    sp2.succ_pred_req <= spr
    succ_pred_pending <= spr{|s| [s[0], budtime, s[2]]}

    # upon response, remove pending
    succ_pred_pending <- (succ_pred_pending * sp2.succ_pred_resp).lefts(:addr => :from)
    # and if not finger[[0]], then rememember in successors
    succ_pred_dist <= sp2.succ_pred_resp {|s| [s.from, (log2(@maxkey) - s.hops).to_i, s.start, s.pred_id, s.pred_addr]}
    successors <+ succ_pred_dist do |s|
      unless me.first.nil? or finger[[0]].nil? or s.dist == 0
        [s.dist, s.start, s.from, (s.start - me.first.start) % @maxkey]
      end
    end
    successors <- (succ_pred_dist * successors).rights(:dist => :index)

    # on sp2.succ_pred_timeout, swap in a new finger[[0]] as needed
    mos <= (succ_timer * successors).rights
    min_successor <= mos.argmin([], :dist)
    finger <+- (sp2.succ_pred_timeout * min_successor).pairs do |s, m|
      if finger[[0]] and s.to == finger[[0]].succ_addr
        [0, finger[[0]].start, finger[[0]].hi, m.start, m.addr]
      end
    end
  end
end


text:
var mongoose = require('mongoose');
var Schema = mongoose.Schema;

var bookModel = new Schema({
	tittle : {
		type : String
	}
	// author : {type : String},
	// gener : {type : String},
	// read : {type : Boolean , default : false}

});

module.exports  = mongoose.model('book' , bookModel);


text:
/*
Metodo que crea la accion HMK_DATA_OK segun el objeto del response
*/
export const getHmkOk = (data) => {
	return {
		type: 'GET_HMK_OK',
		data
	};
};

/*
Metodo que crea la accion HMK_DATA_ERR segun el objeto del response
*/
export const getHmkErr = (err) => {
	return {
		type: 'GET_HMK_ERR',
		err
	};
};

/*
Metodo que crea la accion HMK_DATA_OK segun el objeto del response
*/
export const postHmkOk = (data) => {
	return {
		type: 'POST_HMK_OK',
		data
	};
};

/*
Metodo que crea la accion HMK_DATA_ERR segun el objeto del response
*/
export const postHmkErr = (err) => {
	return {
		type: 'POST_HMK_ERR',
		err
	};
};
/*
Metodo que crea la accion HMK_DATA_OK segun el objeto del response
*/
export const putHmkOk = (data) => {
	return {
		type: 'PUT_HMK_OK',
		data
	};
};

/*
Metodo que crea la accion HMK_DATA_ERR segun el objeto del response
*/
export const putHmkErr = (err) => {
	return {
		type: 'PUT_HMK_ERR',
		err
	};
};
/*
Metodo que crea la accion HMK_DATA_OK segun el objeto del response
*/
export const deleteHmkOk = (data) => {
	return {
		type: 'DELETE_HMK_OK',
		data
	};
};

/*
Metodo que crea la accion HMK_DATA_ERR segun el objeto del response
*/
export const deleteHmkErr = (err) => {
	return {
		type: 'DELETE_HMK_ERR',
		err
	};
};

/*
Metodo que crea la accion USER_DATA_OK segun el objeto del response
*/
export const getUserOk = (data) => {
	return {
		type: 'GET_USER_OK',
		data
	};
};

/*
Metodo que crea la accion USER_DATA_ERR segun el objeto del response
*/
export const getUserErr = (err) => {
	return {
		type: 'GET_USER_ERR',
		err
	};
};

/*
Metodo que crea la accion PUT_USER segun el objeto user
*/
export const putUserOk = (user) => {
	return {
		type: 'PUT_USER_OK',
		user
	};
};

/*
Metodo que crea la accion PUT_USER segun el objeto user
*/
export const putUserErr = (user) => {
	return {
		type: 'PUT_USER_ERR',
		user
	};
};

/*
Metodo que crea la accion TOGGLE_EDIT_USER segun el objeto user
*/
export const toggleEditUser = (user) => {
	return {
		type: 'TOGGLE_EDIT_USER',
		user
	};
};

/*
Metodo que crea la accion TOGGLE_EDIT_HMK segun el objeto hmk
*/
export const toggleEditAddHmk = (hmk) => {
	return {
		type: 'TOGGLE_EDIT_ADD_HMK',
		hmk
	};
};

export const toggleLoginView = () => {
	return {
		type: 'TOGGLE_LOGIN_VIEW'
	};
};

export const toggleUserLoading = () => {
	return {
		type: 'TOGGLE_USER_LOADING'
	};
}

export const toggleHmkLoading = () => {
	return {
		type: 'TOGGLE_HMK_LOADING'
	};
}

export const toggleNewHmkLoading = () => {
	return {
		type: 'TOGGLE_NEW_HMK_LOADING'
	};
}