text:
package com.netflix.atlas.core.model

sealed trait ConsolidationFunction {
  def name: String
  def compute(b: Block, pos: Int, aggr: Int, multiple: Int): Double
  override def toString: String = s":cf-$name"
}

object ConsolidationFunction {
  import java.lang.{Double => JDouble}

  sealed trait SumOrAvgCf extends ConsolidationFunction

  case object Avg extends SumOrAvgCf {
    def name: String = "avg"

    def compute(b: Block, pos: Int, aggr: Int, multiple: Int): Double = {
      val end = pos + multiple
      var total = 0.0
      var count = 0
      var nanCount = 0
      var i = pos
      while (i < end) {
        val v = b.get(i, aggr)
        if (!JDouble.isNaN(v)) {
          total += v
          count += 1
        } else {
          nanCount += 1
        }
        i += 1
      }
      if (count == 0) Double.NaN else total / (count + nanCount)
    }
  }

  case object Sum extends SumOrAvgCf {
    def name: String = "sum"

    def compute(b: Block, pos: Int, aggr: Int, multiple: Int): Double = {
      val end = pos + multiple
      var total = 0.0
      var count = 0
      var i = pos
      while (i < end) {
        val v = b.get(i, aggr)
        if (!JDouble.isNaN(v)) {
          total += v
          count += 1
        }
        i += 1
      }
      if (count == 0) Double.NaN else total
    }
  }

  case object Min extends ConsolidationFunction {
    def name: String = "min"

    def compute(b: Block, pos: Int, aggr: Int, multiple: Int): Double = {
      val end = pos + multiple
      var min = JDouble.MAX_VALUE
      var count = 0
      var i = pos
      while (i < end) {
        val v = b.get(i, aggr)
        if (!JDouble.isNaN(v)) {
          min = math.min(min, v)
          count += 1
        }
        i += 1
      }
      if (count == 0) Double.NaN else min
    }
  }

  case object Max extends ConsolidationFunction {
    def name: String = "max"

    def compute(b: Block, pos: Int, aggr: Int, multiple: Int): Double = {
      val end = pos + multiple
      var max = -JDouble.MAX_VALUE
      var count = 0
      var i = pos
      while (i < end) {
        val v = b.get(i, aggr)
        if (!JDouble.isNaN(v)) {
          max = math.max(max, v)
          count += 1
        }
        i += 1
      }
      if (count == 0) Double.NaN else max
    }
  }
}


text:
<?php

class RosController extends AppController {

/**
 * The used helpers for the controller.
 *
 * @var array
 */
	public $helpers = array('Html');

/**
 * The used components for the controller.
 *
 * @var array
 */
	public $components = array('Session', 'Auth' => array('authorize' => 'Controller'));

/**
 * The admin index displays the relevant menu items.
 *
 * @return null
 */
	public function admin_index() {
		$this->set('title_for_layout', 'ROS Settings');
	}
}

redpajama_set_name: RedPajamaGithub


text:
<?php

namespace app\modules\organization;

class Organization extends \yii\base\Module
{
    public $controllerNamespace = 'app\modules\organization\controllers';

    public function init()
    {
        parent::init();

        // custom initialization code goes here
    }
}


text:
import logging
from pyvisdk.exceptions import InvalidArgumentError

########################################
# Automatically generated, do not edit.
########################################

log = logging.getLogger(__name__)

def CustomizationIPSettings(vim, *args, **kwargs):
    '''IP settings for a virtual network adapter.'''

    obj = vim.client.factory.create('ns0:CustomizationIPSettings')

    # do some validation checking...
    if (len(args) + len(kwargs)) < 1:
        raise IndexError('Expected at least 2 arguments got: %d' % len(args))

    required = [ 'ip' ]
    optional = [ 'dnsDomain', 'dnsServerList', 'gateway', 'ipV6Spec', 'netBIOS', 'primaryWINS',
        'secondaryWINS', 'subnetMask', 'dynamicProperty', 'dynamicType' ]

    for name, arg in zip(required+optional, args):
        setattr(obj, name, arg)

    for name, value in kwargs.items():
        if name in required + optional:
            setattr(obj, name, value)
        else:
            raise InvalidArgumentError("Invalid argument: %s.  Expected one of %s" % (name, ", ".join(required + optional)))

    return obj


text:
'use strict';

// Requires meanio
var mean = require('meanio');
// Creates and serves mean application
mean.serve({ /*options placeholder*/ }, function (app, config) {
   console.log('Mean app started on port ' + config.port + ' (' + process.env.NODE_ENV + ')');
});


text:
package org.apache.flex.compiler.tree.as;

/**
 * An AST node representing a default xml namespace statement.
 *

 * The typical shape of this node is:
 *

 * IDefaultXMLNamespaceNode
 *   IExpressionNode <-- getExpressionNode()
 *

 * For example, default xml namespace = "http://ns.whatever.com" is represented as
 *

 * IDefaultXMLNamespaceNode
 *   ILiteralNode "http://ns.whatever.com"
 *

 */
public interface IDefaultXMLNamespaceNode extends IASNode
{
    /**
     * Gets the node representing the
     * default xml namespace keyword.
     *

     * This is not considered a child node.
     *
     * @return An {@link IKeywordNode}.
     */
    IKeywordNode getKeywordNode();

    /**
     * Gets the child node representing the namespace expression
     * on the right-hand-side of the statement.
     *

     * This is the sole child node.
     *
     * @return An {@link IExpressionNode}.
     */
    IExpressionNode getExpressionNode();
}


text:
package org.elasticsearch.action.admin.indices.get;

import com.google.common.collect.ObjectArrays;

import org.elasticsearch.action.ActionRequestValidationException;
import org.elasticsearch.action.support.master.info.ClusterInfoRequest;
import org.elasticsearch.common.io.stream.StreamInput;
import org.elasticsearch.common.io.stream.StreamOutput;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;

/**
 * A request to delete an index. Best created with {@link org.elasticsearch.client.Requests#deleteIndexRequest(String)}.
 */
public class GetIndexRequest extends ClusterInfoRequest<GetIndexRequest> {

    public static enum Feature {
        ALIASES((byte) 0, "_aliases", "_alias"),
        MAPPINGS((byte) 1, "_mappings", "_mapping"),
        SETTINGS((byte) 2, "_settings"),
        WARMERS((byte) 3, "_warmers", "_warmer");

        private static final Feature[] FEATURES = new Feature[Feature.values().length];

        static {
            for (Feature feature : Feature.values()) {
                assert feature.id() < FEATURES.length && feature.id() >= 0;
                FEATURES[feature.id] = feature;
            }
        }

        private final List<String> validNames;
        private final String preferredName;
        private final byte id;

        private Feature(byte id, String... validNames) {
            assert validNames != null && validNames.length > 0;
            this.id = id;
            this.validNames = Arrays.asList(validNames);
            this.preferredName = validNames[0];
        }

        public byte id() {
            return id;
        }

        public String preferredName() {
            return preferredName;
        }

        public boolean validName(String name) {
            return this.validNames.contains(name);
        }

        public static Feature fromName(String name) {
            for (Feature feature : Feature.values()) {
                if (feature.validName(name)) {
                    return feature;
                }
            }
            throw new IllegalArgumentException("No feature for name [" + name + "]");
        }

        public static Feature fromId(byte id) {
            if (id < 0 || id >= FEATURES.length) {
                throw new IllegalArgumentException("No mapping for id [" + id + "]");
            }
            return FEATURES[id];
        }

        public static Feature[] convertToFeatures(String... featureNames) {
            Feature[] features = new Feature[featureNames.length];
            for (int i = 0; i < featureNames.length; i++) {
                features[i] = Feature.fromName(featureNames[i]);
            }
            return features;
        }
    }

    private static final Feature[] DEFAULT_FEATURES = new Feature[] { Feature.ALIASES, Feature.MAPPINGS, Feature.SETTINGS, Feature.WARMERS };
    private Feature[] features = DEFAULT_FEATURES;
    private boolean humanReadable = false;

    public GetIndexRequest features(Feature... features) {
        if (features == null) {
            throw new IllegalArgumentException("features cannot be null");
        } else {
            this.features = features;
        }
        return this;
    }

    public GetIndexRequest addFeatures(Feature... features) {
        if (this.features == DEFAULT_FEATURES) {
            return features(features);
        } else {
            return features(ObjectArrays.concat(featuresAsEnums(), features, Feature.class));
        }
    }

    public Feature[] features() {
        return features;
    }

    /**
     * @deprecated use {@link #features()} instead
     */
    @Deprecated
    public Feature[] featuresAsEnums() {
        return features();
    }

    @Override
    public ActionRequestValidationException validate() {
        return null;
    }

    public GetIndexRequest humanReadable(boolean humanReadable) {
        this.humanReadable = humanReadable;
        return this;
    }

    public boolean humanReadable() {
        return humanReadable;
    }

    @Override
    public void readFrom(StreamInput in) throws IOException {
        super.readFrom(in);
        int size = in.readVInt();
        features = new Feature[size];
        for (int i = 0; i < size; i++) {
            features[i] = Feature.fromId(in.readByte());
        }
        humanReadable = in.readBoolean();
    }

    @Override
    public void writeTo(StreamOutput out) throws IOException {
        super.writeTo(out);
        out.writeVInt(features.length);
        for (Feature feature : features) {
            out.writeByte(feature.id);
        }
        out.writeBoolean(humanReadable);
    }

}


text:
#pragma once
#include <aws/location/LocationService_EXPORTS.h>
#include <aws/location/LocationServiceRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>

namespace Aws
{
namespace LocationService
{
namespace Model
{

  /**
   */
  class AWS_LOCATIONSERVICE_API GetMapSpritesRequest : public LocationServiceRequest
  {
  public:
    GetMapSpritesRequest();

    // Service request name is the Operation name which will send this request out,
    // each operation should has unique request name, so that we can get operation's name from this request.
    // Note: this is not true for response, multiple operations may have the same response name,
    // so we can not get operation's name from response.
    inline virtual const char* GetServiceRequestName() const override { return "GetMapSprites"; }

    Aws::String SerializePayload() const override;

    /**
     *
The name of the sprite file. Use the following file names for the sprite
     * sheet:

 sprites.png

     * sprites@2x.png for high pixel density displays

     *
For the JSON document contain image offsets. Use the following file names:

     *

 sprites.json

     * sprites@2x.json for high pixel density displays

     */
    inline const Aws::String& GetFileName() const{ return m_fileName; }

    /**
     *
The name of the sprite file. Use the following file names for the sprite
     * sheet:

 sprites.png

     * sprites@2x.png for high pixel density displays

     *
For the JSON document contain image offsets. Use the following file names:

     *

 sprites.json

     * sprites@2x.json for high pixel density displays

     */
    inline bool FileNameHasBeenSet() const { return m_fileNameHasBeenSet; }

    /**
     *
The name of the sprite file. Use the following file names for the sprite
     * sheet:

 sprites.png

     * sprites@2x.png for high pixel density displays

     *
For the JSON document contain image offsets. Use the following file names:

     *

 sprites.json

     * sprites@2x.json for high pixel density displays

     */
    inline void SetFileName(const Aws::String& value) { m_fileNameHasBeenSet = true; m_fileName = value; }

    /**
     *
The name of the sprite file. Use the following file names for the sprite
     * sheet:

 sprites.png

     * sprites@2x.png for high pixel density displays

     *
For the JSON document contain image offsets. Use the following file names:

     *

 sprites.json

     * sprites@2x.json for high pixel density displays

     */
    inline void SetFileName(Aws::String&& value) { m_fileNameHasBeenSet = true; m_fileName = std::move(value); }

    /**
     *
The name of the sprite file. Use the following file names for the sprite
     * sheet:

 sprites.png

     * sprites@2x.png for high pixel density displays

     *
For the JSON document contain image offsets. Use the following file names:

     *

 sprites.json

     * sprites@2x.json for high pixel density displays

     */
    inline void SetFileName(const char* value) { m_fileNameHasBeenSet = true; m_fileName.assign(value); }

    /**
     *
The name of the sprite file. Use the following file names for the sprite
     * sheet:

 sprites.png

     * sprites@2x.png for high pixel density displays

     *
For the JSON document contain image offsets. Use the following file names:

     *

 sprites.json

     * sprites@2x.json for high pixel density displays

     */
    inline GetMapSpritesRequest& WithFileName(const Aws::String& value) { SetFileName(value); return *this;}

    /**
     *
The name of the sprite file. Use the following file names for the sprite
     * sheet:

 sprites.png

     * sprites@2x.png for high pixel density displays

     *
For the JSON document contain image offsets. Use the following file names:

     *

 sprites.json

     * sprites@2x.json for high pixel density displays

     */
    inline GetMapSpritesRequest& WithFileName(Aws::String&& value) { SetFileName(std::move(value)); return *this;}

    /**
     *
The name of the sprite file. Use the following file names for the sprite
     * sheet:

 sprites.png

     * sprites@2x.png for high pixel density displays

     *
For the JSON document contain image offsets. Use the following file names:

     *

 sprites.json

     * sprites@2x.json for high pixel density displays

     */
    inline GetMapSpritesRequest& WithFileName(const char* value) { SetFileName(value); return *this;}

    /**
     *
The map resource associated with the sprite file.

     */
    inline const Aws::String& GetMapName() const{ return m_mapName; }

    /**
     *
The map resource associated with the sprite file.

     */
    inline bool MapNameHasBeenSet() const { return m_mapNameHasBeenSet; }

    /**
     *
The map resource associated with the sprite file.

     */
    inline void SetMapName(const Aws::String& value) { m_mapNameHasBeenSet = true; m_mapName = value; }

    /**
     *
The map resource associated with the sprite file.

     */
    inline void SetMapName(Aws::String&& value) { m_mapNameHasBeenSet = true; m_mapName = std::move(value); }

    /**
     *
The map resource associated with the sprite file.

     */
    inline void SetMapName(const char* value) { m_mapNameHasBeenSet = true; m_mapName.assign(value); }

    /**
     *
The map resource associated with the sprite file.

     */
    inline GetMapSpritesRequest& WithMapName(const Aws::String& value) { SetMapName(value); return *this;}

    /**
     *
The map resource associated with the sprite file.

     */
    inline GetMapSpritesRequest& WithMapName(Aws::String&& value) { SetMapName(std::move(value)); return *this;}

    /**
     *
The map resource associated with the sprite file.

     */
    inline GetMapSpritesRequest& WithMapName(const char* value) { SetMapName(value); return *this;}

  private:

    Aws::String m_fileName;
    bool m_fileNameHasBeenSet;

    Aws::String m_mapName;
    bool m_mapNameHasBeenSet;
  };

} // namespace Model
} // namespace LocationService
} // namespace Aws


text: sudo apt-get install --only-upgrade python-moinmoin=1.9.3-1ubuntu2.3 -y


number_of_participants: Number of Participants

register_participants: Register Participants

participant_registered: Successfully registered {{participantCount}} participants

print_labels: Print Labels


text:
<?xml version="1.0"?>

<!DOCTYPE suppressions PUBLIC
    "-//Puppy Crawl//DTD Suppressions 1.1//EN"
    "http://www.puppycrawl.com/dtds/suppressions_1_1.dtd">

<suppressions>
    <suppress checks="HideUtilityClassConstructor" files="\w*TestSuite\.java" /> <!-- TestSuites are no utility classes -->
    <suppress checks="JavaNCSS" files="\w*TestSuite\.java" /> <!-- Test suites can (and should) have lots and lots of tests so it makes no sense to force them to be small -->
    <suppress checks="ClassFanOutComplexity" files="\w*Test\.java" /> <!-- Tests will likely be dependent on too many classes if the class under test depends on too many classes. Refactoring the class under test should solve this for the tests as well -->
    <suppress checks="AvoidStarImport" files="\w*Test\.java" /> <!-- Simplifies multiple static imports for mocks, matchers and builder -->
    <suppress checks="IllegalThrows" files="\w*Test(Case)?\.java" /> <!-- Test, setup and teardown methods should throw Exception instead of handling those themselves -->
</suppressions>


text:
'use strict';

const rimraf = require('rimraf');
const chalk = require('chalk');

const autodocs = {

  run(name, options) {
    const self = this;
    const config = self.app.clerk.autodocs.config();
    const lib = String(name).trim();
    let libs = [];
    options = options || {};
    options.rebuild = options.rebuild || true;
    options.loader = options.loader || function () {};
    options.done = options.done || function () {};

    const progress = function (data) {
      options.loader(self.drawLoader(data.downloaded, data.total, data.action));
    };

    if (!config) {
      options.done(`Wat had trouble reading "./config/config.auto.json".`);
      return;
    }

    if (lib === 'all') {
      libs = Object.keys(config);
    } else {
      if (!config[lib]) {
        options.done(`${lib} is not on Wat's list of auto-updating libraries.\n  To include it, add it to ./config/config.auto.json and submit a PR.`);
        return;
      }
      libs.push(lib);
    }

    function runSingleLibrary(libName) {
      const data = config[libName];
      data.urls = data.urls || [];
      data.language = data.language || 'javascript';
      data.parser = data.parser || 'readme';

      if (!libName) {
        options.done('${libName} is not a valid autodoc library name.');
        return;
      }

      // Load the appropriate parser.
      const parser = autodocs.parsers[data.parser];
      if (autodocs.parsers[data.parser] === undefined) {
        options.done(`${libName} has an invalid autodoc parser: ${data.parser}.`);
        return;
      }

      const opt = {
        urls: data.urls,
        language: data.language,
        aliases: data.aliases,
        parser: data.parser,
        static: data.static,
        crawl: false,
        progress
      };

      progress({action: 'fetch', total: 50, downloaded: 0});
      parser.run(libName, opt, function () {
        if (libs.length < 1) {
          if (options.rebuild) {
            progress({action: 'index', total: 50, downloaded: 50});
            self.app.clerk.indexer.build(function (index, localIndex) {
              self.app.clerk.indexer.write(undefined, localIndex);
              progress({action: 'done', total: 50, downloaded: 50});
              self.app.vorpal.emit('wat_library_build', {name: libName});
              options.done();
            });
          } else {
            options.done();
          }
        } else {
          runSingleLibrary(libs.shift());
        }
      });
    }

    runSingleLibrary(libs.shift());
  },

  delete(name, opt, callback) {
    const options = options || {};
    options.rebuild = opt.rebuild || true;
    const self = this;
    const autodocPath = `${self.app.clerk.paths.static.autodocs}${name}`;
    const localAutodocPath = `${self.app.clerk.paths.temp.autodocs}${name}`;
    const config = self.app.clerk.autodocs.config();

    if (config[name] === undefined) {
      callback(`\n  ${name} isn't an auto-generated library. Did you get the spelling right?\n`);
      return;
    }

    if (config[name].static === true) {
      callback(`\n  ${name} is a permanent library and cannot be unbuilt.\n`);
      return;
    }

    try {
      if (options.static) {
        rimraf.sync(autodocPath);
      }
      rimraf.sync(localAutodocPath);
    } catch (e) {}

    if (options.rebuild === true) {
      self.app.clerk.indexer.build(function (index, localIndex) {
        self.app.clerk.indexer.write(undefined, localIndex);
        callback();
      });
    } else {
      callback();
    }
  },

  deleteAll(options, callback) {
    const self = this;
    const config = this.app.clerk.autodocs.config();
    const index = this.app.clerk.indexer.index();
    options = options || {};

    if (config === undefined) {
      callback(`\n  Trouble reading autodoc config.\n`);
      return;
    }

    // Whip up all built autodoc libs.
    const names = [];
    for (const name in config) {
      if (config[name].static !== true) {
        if (index[name] && index[name].__class === 'lib') {
          names.push(name);
        }
      }
    }

    // Uh... what's the point.
    if (names.length < 1) {
      callback();
      return;
    }

    // Handler is called on each delete.
    // When all libs are deleted, we build the
    // index again and callback.
    const total = names.length;
    let done = 0;
    function handler() {
      done++;
      if (done === total) {
        self.app.clerk.indexer.build(function (index, localIndex) {
          self.app.clerk.indexer.write(undefined, localIndex);
          callback();
        });
      } else {
        go();
      }
    }

    function go() {
      if (names.length > 0) {
        const name = names.shift();
        if (options.progress) {
          options.progress(name);
        }
        self.delete(name, {rebuild: false}, handler);
      } else {
        handler();
      }
    }

    go();
  },

  drawLoader(done, total, action) {
    // Add time on to the end of the
    // loader to compensate for building.
    const doneString = done;
    let multiple = 0.55;
    if (action === 'parse') {
      multiple = 0.60;
    } else if (action === 'build') {
      multiple = 0.65;
    } else if (action === 'write') {
      multiple = 0.70;
    } else if (action === 'index') {
      multiple = 0.75;
    } else if (action === 'done') {
      multiple = 0.80;
    }
    done = Math.floor(done * multiple);
    done = (done < 0) ? 0 : done;
    const width = 40;
    let loader = '';
    for (let i = 0; i < width; ++i) {
      if (i <= done) {
        loader += chalk.bgGreen(' ');
      } else {
        loader += chalk.bgWhite(' ');
      }
    }
    let buildStr;
    if (total === 100) {
      buildStr = `Preparing...`;
    } else if (action === 'fetch') {
      if (doneString === 0) {
        buildStr = `Fetching docs...`;
      } else {
        buildStr = `Fetching ${doneString} of ${total} docs...`;
      }
    } else if (['parse', 'build'].indexOf(action) > -1) {
      buildStr = `Housekeeping...`;
    } else if (['write', 'index', 'done'].indexOf(action) > -1) {
      buildStr = `Feng shui...`;
    }
    buildStr = chalk.grey(buildStr);
    const result = `\n  ${buildStr}\n\n  ${loader}\n`;
    return result;
  }
};

module.exports = function (app) {
  autodocs.parsers = {};
  autodocs.parsers.markdown = require('./parser/markdown/index')(app);
  autodocs.app = app;
  return autodocs;
};


text:
module MaZMQ
  class Proxy
    include MaZMQ::Proxy::Backend

    #@@id = 0

    def initialize
      @balancer = MaZMQ::Proxy::Balancer.new

      # @max_timeouts = 5 # TODO
      # @max_timeouted = 1
      # @max_retries

      super
    end

    def send_string(msg)
      @current = current_socket
      return false if @current.is_a? NilClass
      case @current.state
        when :idle
          @current.send_string(msg)
        else
          return false
      end
      @balancer.next
    end

    def connect(protocol, address, port)
      return false if addresses.include? "#{protocol}://#{address}:#{port.to_s}"
      index = super(protocol, address, port)
      #@balancer.curent refresh ! TODO
      @balancer.add(index)
      index
    end

    def disconnect(index)
      @balancer.remove(index)
      super(index)
    end

    def close
      @sockets.each do |s|
        s.close
      end
    end

    def addresses
      @sockets.collect{|s| s.addresses}.flatten
    end

    def current_socket
      @sockets[@balancer.current]
    end
  end
end


text:
<?php

namespace EarDish\MFP\APIHandlerBundle\Entity;

use Doctrine\ORM\EntityRepository;

/**
 * ImageFormatRepository
 *
 * This class was generated by the Doctrine ORM. Add your own custom
 * repository methods below.
 */
class ImageFormatRepository extends EntityRepository
{
    public function findOneByIdAndFormat($id, $format) {
        return $this->getEntityManager()
                ->createQuery(
                        'SELECT i
                            FROM EarDishMFPAPIHandlerBundle:ImageFormat i
                            WHERE i.format = :format AND i.image = :id')
                ->setParameter("format", $format)
                ->setParameter("id", $id)
                ->getSingleResult();
    }
}


text:
using System;
using System.Globalization;
using System.Windows.Data;
using System.Windows.Markup;

namespace AppLib.WPF.Converters
{
    /// <summary>
    /// Base for converters to be usesd as Markup extensions
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public abstract class ConverterBase<T> : MarkupExtension where T: new()
    {
        /// <summary>
        /// Convereters are singletons
        /// </summary>
        private static T _converter;

        /// <summary>
        /// Returns an object that is provided as the value of the target property for this markup extension
        /// </summary>
        /// <param name="serviceProvider">A service provider helper that can provide services for the markup extension</param>
        /// <returns>The object value to set on the property where the extension is applied.</returns>
        public override object ProvideValue(IServiceProvider serviceProvider)
        {
            if (_converter == null)
            {
                _converter = new T();
            }
            return _converter;
        }
    }
}


text:
#include<pcl/io/jpeg_io.h>
#include <jpeglib.h>
#include<pcl/io/impl/jpeg_io.hpp>
#include <setjmp.h>
#include <stdio.h>

using namespace pcl;
using namespace io;

#ifdef _WIN32
template class PCL_EXPORTS pcl::io::JPEGReader<uint8_t>;
#endif//_WIN32
template class PCL_EXPORTS pcl::io::JPEGReader<char>;
template class PCL_EXPORTS pcl::io::JPEGReader<unsigned char>;

#ifdef _WIN32
template class PCL_EXPORTS pcl::io::JPEGWriter<uint8_t>;
#endif//_WIN32
template class PCL_EXPORTS pcl::io::JPEGWriter<char>;
template class PCL_EXPORTS pcl::io::JPEGWriter<unsigned char>;


text:
<!doctype html>
<html>
<head>
  <title>Jasmine Spec Runner</title>
  <link rel="stylesheet" type="text/css" href="css/jasmine.css">
  <script src="js/libs/requirejs/require.js" data-main="js/tests/config/TestInit"></script>
</head>
<body>
</body>
</html>


text:
package com.buession.mcrypt;

public class CharSimpleMD5Mcrypt {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		char[] data = {'1', '2', '3', '4', '5', '6'};

		Mcrypt mcrypt = new MD5Mcrypt("UTF-8", Constants.SALT);

		System.out.println(new String(data));
		System.out.println(mcrypt.encode(data));
	}

}


text:
{% load i18n %}
{% load wagtailadmin_tags %}

{% comment %}
    Expects a variable 'page', a page object.
    Tests whether that page is locked for editing, and if so, outputs a 'locked' icon.
{% endcomment %}

{% if page.locked %}
    <span
        class="indicator locked-indicator {% if page.locked_by == request.user %}indicator--is-inverse{% endif %}"
        title="{% if page.locked_by == request.user %}{% trans 'This page is locked, by you, to further editing' %}{% else %}{% trans 'This page is locked to further editing' %}{% endif %}"
    >
        {% icon name="lock" class_name="initial" %}
    </span>
{% endif %}


text:
This gem implements skeleton algorithm from [Unicode TR39](http://www.unicode.org/reports/tr39/)

### Usages

    require 'tr39_confusables'

    Tr39Confusables.skeleton("𝔭𝒶ỿ𝕡𝕒ℓ")  # "paypal"
    Tr39Confusables.is_confusable?("scope", "scope")  # true

*Note on the use of `Skeleton`, from TR39:*

> A skeleton is intended only for internal use for testing confusability of strings; the resulting text is not suitable for display to users, because it will appear to be a hodgepodge of different scripts. In particular, the result of mapping an identifier will not necessary be an identifier. Thus the confusability mappings can be used to test whether two identifiers are confusable (if their skeletons are the same), but should definitely not be used as a "normalization" of identifiers.


text:
namespace Sharpen
{
	using System;
	using System.Collections;
	using System.Collections.Generic;
	using System.Reflection;

	public class CopyOnWriteArrayList<T> : Iterable<T>, IEnumerable, ICollection<T>, IEnumerable<T>, IList<T>
	{
		private List<T> list;

		public CopyOnWriteArrayList ()
		{
			this.list = new List<T> ();
		}

		public virtual void Add (T element)
		{
			lock (list) {
				List<T> newList = new List<T> (list);
				newList.Add (element);
				list = newList;
			}
		}

		public virtual void Add (int index, T element)
		{
			lock (list) {
				List<T> newList = new List<T> (list);
				newList.Insert (index, element);
				list = newList;
			}
		}

		public virtual void Clear ()
		{
			lock (list) {
				list = new List<T> ();
			}
		}

		public virtual T Get (int index)
		{
			return list[index];
		}

		public override Iterator<T> Iterator ()
		{
			return new EnumeratorWrapper<T> (list, list.GetEnumerator ());
		}

		public virtual T Remove (int index)
		{
			lock (list) {
				T old = list[index];
				List<T> newList = new List<T> (list);
				newList.RemoveAt (index);
				list = newList;
				return old;
			}
		}

		public virtual T Set (int index, T element)
		{
			lock (list) {
				T old = list[index];
				List<T> newList = new List<T> (list);
				newList[index] = element;
				list = newList;
				return old;
			}
		}

		bool ICollection<T>.Contains (T item)
		{
			return list.Contains (item);
		}

		void ICollection<T>.CopyTo (T[] array, int arrayIndex)
		{
			list.CopyTo (array, arrayIndex);
		}

		bool ICollection<T>.Remove (T item)
		{
			lock (list) {
				List<T> newList = new List<T> (list);
				bool removed = newList.Remove (item);
				list = newList;
				return removed;
			}
		}

		int IList<T>.IndexOf (T item)
		{
			int num = 0;
			foreach (T t in this) {
				if (object.ReferenceEquals (t, item) || t.Equals (item))
					return num;
				num++;
			}
			return -1;
		}

		void IList<T>.Insert (int index, T item)
		{
			Add (index, item);
		}

		void IList<T>.RemoveAt (int index)
		{
			Remove (index);
		}

		public virtual int Count {
			get { return list.Count; }
		}

		public T this[int n] {
			get { return Get (n); }
			set { Set (n, value); }
		}

		bool ICollection<T>.IsReadOnly {
			get { return false; }
		}
	}
}


text:
<?xml version="1.0" encoding="iso-8859-1"?>
<!DOCTYPE html
    PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "DTD/xhtml1-strict.dtd">

  <title>Qt 4.3: window.cpp Example File (opengl/hellogl/window.cpp)</title>
  <link href="classic.css" rel="stylesheet" type="text/css" />

  	Home · All Classes · Main Classes · Grouped Classes · Modules · Functions

window.cpp Example File
opengl/hellogl/window.cpp

 #include <QtGui>

 #include "glwidget.h"
 #include "window.h"

 Window::Window()
 {
     glWidget = new GLWidget;

     xSlider = createSlider();
     ySlider = createSlider();
     zSlider = createSlider();

     connect(xSlider, SIGNAL(valueChanged(int)), glWidget, SLOT(setXRotation(int)));
     connect(glWidget, SIGNAL(xRotationChanged(int)), xSlider, SLOT(setValue(int)));
     connect(ySlider, SIGNAL(valueChanged(int)), glWidget, SLOT(setYRotation(int)));
     connect(glWidget, SIGNAL(yRotationChanged(int)), ySlider, SLOT(setValue(int)));
     connect(zSlider, SIGNAL(valueChanged(int)), glWidget, SLOT(setZRotation(int)));
     connect(glWidget, SIGNAL(zRotationChanged(int)), zSlider, SLOT(setValue(int)));

     QHBoxLayout *mainLayout = new QHBoxLayout;
     mainLayout->addWidget(glWidget);
     mainLayout->addWidget(xSlider);
     mainLayout->addWidget(ySlider);
     mainLayout->addWidget(zSlider);
     setLayout(mainLayout);

     xSlider->setValue(15 * 16);
     ySlider->setValue(345 * 16);
     zSlider->setValue(0 * 16);
     setWindowTitle(tr("Hello GL"));
 }

 QSlider *Window::createSlider()
 {
     QSlider *slider = new QSlider(Qt::Vertical);
     slider->setRange(0, 360 * 16);
     slider->setSingleStep(16);
     slider->setPageStep(15 * 16);
     slider->setTickInterval(15 * 16);
     slider->setTickPosition(QSlider::TicksRight);
     return slider;
 }

<address>

Copyright © 2008 Trolltech
Trademarks

Qt 4.3.5

</address>


text:
package org.pageseeder.ox.callback;

import org.pageseeder.ox.api.Result;
import org.pageseeder.ox.api.StepInfo;
import org.pageseeder.ox.core.Model;
import org.pageseeder.ox.core.PackageData;
import org.pageseeder.ox.tool.DefaultResult;
import org.pageseeder.ox.tool.ExtraResultStringXML;
import org.pageseeder.ox.util.FileUtils;
import org.pageseeder.ox.util.StepUtils;
import org.pageseeder.ox.util.XSLT;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import java.io.File;
import java.io.IOException;

/**
 * Transform the result xml in something else.
 *
 *

 *
callback-xslt it will be used to change the result XML.

 *
callback-output The place where the transformed XML will be placed.

 *

 * @author ccabral
 * @since 3 December 2021
 */
public class TransformOutput extends Transform {
  private final static Logger LOGGER = LoggerFactory.getLogger(TransformResult.class);

  @Override
  public void process(Model model, PackageData data, Result result, StepInfo info) {

    try {
      File input = StepUtils.getOutput(data, info, null);
      File xslt = getXSLFile(model, data, info);
      File output = getOutputFile(data, info);

      if (input != null && xslt != null && output != null) {
        Transformer transformer = XSLT.buildXSLTTransformer(xslt, data, info);
        XSLT.transform(input, output, transformer);
        if (result instanceof DefaultResult) {
          String outputXML = FileUtils.read(output);
          outputXML = outputXML.replaceAll("<\\?xml.*\\?>",""); //TODO improve regex
          ((DefaultResult) result).addExtraXML(new ExtraResultStringXML(outputXML));
        }
      }
    } catch (TransformerException | IOException e) {
      LOGGER.error("Callback failed {}", e.getMessage());
    }
  }

}


text:
package org.jeecg.common.system.vo;

/**
 * lvdandan 部门机构model
 */
public class SysDepartModel {
    /**ID*/
    private String id;
    /**父机构ID*/
    private String parentId;
    /**机构/部门名称*/
    private String departName;
    /**英文名*/
    private String departNameEn;
    /**缩写*/
    private String departNameAbbr;
    /**排序*/
    private Integer departOrder;
    /**描述*/
    private String description;
    /**机构类别 1组织机构,2岗位*/
    private String orgCategory;
    /**机构类型*/
    private String orgType;
    /**机构编码*/
    private String orgCode;
    /**手机号*/
    private String mobile;
    /**传真*/
    private String fax;
    /**地址*/
    private String address;
    /**备注*/
    private String memo;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getParentId() {
        return parentId;
    }

    public void setParentId(String parentId) {
        this.parentId = parentId;
    }

    public String getDepartName() {
        return departName;
    }

    public void setDepartName(String departName) {
        this.departName = departName;
    }

    public String getDepartNameEn() {
        return departNameEn;
    }

    public void setDepartNameEn(String departNameEn) {
        this.departNameEn = departNameEn;
    }

    public String getDepartNameAbbr() {
        return departNameAbbr;
    }

    public void setDepartNameAbbr(String departNameAbbr) {
        this.departNameAbbr = departNameAbbr;
    }

    public Integer getDepartOrder() {
        return departOrder;
    }

    public void setDepartOrder(Integer departOrder) {
        this.departOrder = departOrder;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public String getOrgCategory() {
        return orgCategory;
    }

    public void setOrgCategory(String orgCategory) {
        this.orgCategory = orgCategory;
    }

    public String getOrgType() {
        return orgType;
    }

    public void setOrgType(String orgType) {
        this.orgType = orgType;
    }

    public String getOrgCode() {
        return orgCode;
    }

    public void setOrgCode(String orgCode) {
        this.orgCode = orgCode;
    }

    public String getMobile() {
        return mobile;
    }

    public void setMobile(String mobile) {
        this.mobile = mobile;
    }

    public String getFax() {
        return fax;
    }

    public void setFax(String fax) {
        this.fax = fax;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getMemo() {
        return memo;
    }

    public void setMemo(String memo) {
        this.memo = memo;
    }
}


text:
public class Main {
    public static void main(String[] args) {
        // 整型比较
        int option = 1;
        switch (option) {
        case 1:
            System.out.println("Selected 1");
            break;
        case 2:
            System.out.println("Selected 2");
            break;
        case 3:
            System.out.println("Selected 3");
            break;
        default:
            System.out.println("Not selected");
            break;
        }

        // 字符串类型比较
        String fruit = "apple";
        switch (fruit) {
        case "apple":
            System.out.println("Selected apple");
            break;
        case "pear":
            System.out.println("Selected pear");
            break;
        case "mango":
            System.out.println("Selected mango");
            break;
        default:
            System.out.println("No fruit selected");
            break;
        }
    }
}


text:
#ifndef _HYPERV_H
#define _HYPERV_H

#include <uapi/linux/hyperv.h>
#include <uapi/asm/hyperv.h>

#include <linux/types.h>
#include <linux/scatterlist.h>
#include <linux/list.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
#include <linux/completion.h>
#include <linux/device.h>
#include <linux/mod_devicetable.h>

#define MAX_PAGE_BUFFER_COUNT				32
#define MAX_MULTIPAGE_BUFFER_COUNT			32 /* 128K */

#pragma pack(push, 1)

/* Single-page buffer */
struct hv_page_buffer {
	u32 len;
	u32 offset;
	u64 pfn;
};

/* Multiple-page buffer */
struct hv_multipage_buffer {
	/* Length and Offset determines the # of pfns in the array */
	u32 len;
	u32 offset;
	u64 pfn_array[MAX_MULTIPAGE_BUFFER_COUNT];
};

/*
 * Multiple-page buffer array; the pfn array is variable size:
 * The number of entries in the PFN array is determined by
 * "len" and "offset".
 */
struct hv_mpb_array {
	/* Length and Offset determines the # of pfns in the array */
	u32 len;
	u32 offset;
	u64 pfn_array[];
};

/* 0x18 includes the proprietary packet header */
#define MAX_PAGE_BUFFER_PACKET		(0x18 +			\
					(sizeof(struct hv_page_buffer) * \
					 MAX_PAGE_BUFFER_COUNT))
#define MAX_MULTIPAGE_BUFFER_PACKET	(0x18 +			\
					 sizeof(struct hv_multipage_buffer))

#pragma pack(pop)

struct hv_ring_buffer {
	/* Offset in bytes from the start of ring data below */
	u32 write_index;

	/* Offset in bytes from the start of ring data below */
	u32 read_index;

	u32 interrupt_mask;

	/*
	 * Win8 uses some of the reserved bits to implement
	 * interrupt driven flow management. On the send side
	 * we can request that the receiver interrupt the sender
	 * when the ring transitions from being full to being able
	 * to handle a message of size "pending_send_sz".
	 *
	 * Add necessary state for this enhancement.
	 */
	u32 pending_send_sz;

	u32 reserved1[12];

	union {
		struct {
			u32 feat_pending_send_sz:1;
		};
		u32 value;
	} feature_bits;

	/* Pad it to PAGE_SIZE so that data starts on page boundary */
	u8	reserved2[4028];

	/*
	 * Ring data starts here + RingDataStartOffset
	 * !!! DO NOT place any fields below this !!!
	 */
	u8 buffer[0];
} __packed;

struct hv_ring_buffer_info {
	struct hv_ring_buffer *ring_buffer;
	u32 ring_size;			/* Include the shared header */
	spinlock_t ring_lock;

	u32 ring_datasize;		/* < ring_size */
	u32 ring_data_startoffset;
	u32 priv_write_index;
	u32 priv_read_index;
};

/*
 *
 * hv_get_ringbuffer_availbytes()
 *
 * Get number of bytes available to read and to write to
 * for the specified ring buffer
 */
static inline void
hv_get_ringbuffer_availbytes(struct hv_ring_buffer_info *rbi,
			  u32 *read, u32 *write)
{
	u32 read_loc, write_loc, dsize;

	/* Capture the read/write indices before they changed */
	read_loc = rbi->ring_buffer->read_index;
	write_loc = rbi->ring_buffer->write_index;
	dsize = rbi->ring_datasize;

	*write = write_loc >= read_loc ? dsize - (write_loc - read_loc) :
		read_loc - write_loc;
	*read = dsize - *write;
}

static inline u32 hv_get_bytes_to_read(struct hv_ring_buffer_info *rbi)
{
	u32 read_loc, write_loc, dsize, read;

	dsize = rbi->ring_datasize;
	read_loc = rbi->ring_buffer->read_index;
	write_loc = READ_ONCE(rbi->ring_buffer->write_index);

	read = write_loc >= read_loc ? (write_loc - read_loc) :
		(dsize - read_loc) + write_loc;

	return read;
}

static inline u32 hv_get_bytes_to_write(struct hv_ring_buffer_info *rbi)
{
	u32 read_loc, write_loc, dsize, write;

	dsize = rbi->ring_datasize;
	read_loc = READ_ONCE(rbi->ring_buffer->read_index);
	write_loc = rbi->ring_buffer->write_index;

	write = write_loc >= read_loc ? dsize - (write_loc - read_loc) :
		read_loc - write_loc;
	return write;
}

/*
 * VMBUS version is 32 bit entity broken up into
 * two 16 bit quantities: major_number. minor_number.
 *
 * 0 . 13 (Windows Server 2008)
 * 1 . 1  (Windows 7)
 * 2 . 4  (Windows 8)
 * 3 . 0  (Windows 8 R2)
 * 4 . 0  (Windows 10)
 */

#define VERSION_WS2008  ((0 << 16) | (13))
#define VERSION_WIN7    ((1 << 16) | (1))
#define VERSION_WIN8    ((2 << 16) | (4))
#define VERSION_WIN8_1    ((3 << 16) | (0))
#define VERSION_WIN10	((4 << 16) | (0))

#define VERSION_INVAL -1

#define VERSION_CURRENT VERSION_WIN10

/* Make maximum size of pipe payload of 16K */
#define MAX_PIPE_DATA_PAYLOAD		(sizeof(u8) * 16384)

/* Define PipeMode values. */
#define VMBUS_PIPE_TYPE_BYTE		0x00000000
#define VMBUS_PIPE_TYPE_MESSAGE		0x00000004

/* The size of the user defined data buffer for non-pipe offers. */
#define MAX_USER_DEFINED_BYTES		120

/* The size of the user defined data buffer for pipe offers. */
#define MAX_PIPE_USER_DEFINED_BYTES	116

/*
 * At the center of the Channel Management library is the Channel Offer. This
 * struct contains the fundamental information about an offer.
 */
struct vmbus_channel_offer {
	uuid_le if_type;
	uuid_le if_instance;

	/*
	 * These two fields are not currently used.
	 */
	u64 reserved1;
	u64 reserved2;

	u16 chn_flags;
	u16 mmio_megabytes;		/* in bytes * 1024 * 1024 */

	union {
		/* Non-pipes: The user has MAX_USER_DEFINED_BYTES bytes. */
		struct {
			unsigned char user_def[MAX_USER_DEFINED_BYTES];
		} std;

		/*
		 * Pipes:
		 * The following sructure is an integrated pipe protocol, which
		 * is implemented on top of standard user-defined data. Pipe
		 * clients have MAX_PIPE_USER_DEFINED_BYTES left for their own
		 * use.
		 */
		struct {
			u32  pipe_mode;
			unsigned char user_def[MAX_PIPE_USER_DEFINED_BYTES];
		} pipe;
	} u;
	/*
	 * The sub_channel_index is defined in win8.
	 */
	u16 sub_channel_index;
	u16 reserved3;
} __packed;

/* Server Flags */
#define VMBUS_CHANNEL_ENUMERATE_DEVICE_INTERFACE	1
#define VMBUS_CHANNEL_SERVER_SUPPORTS_TRANSFER_PAGES	2
#define VMBUS_CHANNEL_SERVER_SUPPORTS_GPADLS		4
#define VMBUS_CHANNEL_NAMED_PIPE_MODE			0x10
#define VMBUS_CHANNEL_LOOPBACK_OFFER			0x100
#define VMBUS_CHANNEL_PARENT_OFFER			0x200
#define VMBUS_CHANNEL_REQUEST_MONITORED_NOTIFICATION	0x400
#define VMBUS_CHANNEL_TLNPI_PROVIDER_OFFER		0x2000

struct vmpacket_descriptor {
	u16 type;
	u16 offset8;
	u16 len8;
	u16 flags;
	u64 trans_id;
} __packed;

struct vmpacket_header {
	u32 prev_pkt_start_offset;
	struct vmpacket_descriptor descriptor;
} __packed;

struct vmtransfer_page_range {
	u32 byte_count;
	u32 byte_offset;
} __packed;

struct vmtransfer_page_packet_header {
	struct vmpacket_descriptor d;
	u16 xfer_pageset_id;
	u8  sender_owns_set;
	u8 reserved;
	u32 range_cnt;
	struct vmtransfer_page_range ranges[1];
} __packed;

struct vmgpadl_packet_header {
	struct vmpacket_descriptor d;
	u32 gpadl;
	u32 reserved;
} __packed;

struct vmadd_remove_transfer_page_set {
	struct vmpacket_descriptor d;
	u32 gpadl;
	u16 xfer_pageset_id;
	u16 reserved;
} __packed;

/*
 * This structure defines a range in guest physical space that can be made to
 * look virtually contiguous.
 */
struct gpa_range {
	u32 byte_count;
	u32 byte_offset;
	u64 pfn_array[0];
};

/*
 * This is the format for an Establish Gpadl packet, which contains a handle by
 * which this GPADL will be known and a set of GPA ranges associated with it.
 * This can be converted to a MDL by the guest OS.  If there are multiple GPA
 * ranges, then the resulting MDL will be "chained," representing multiple VA
 * ranges.
 */
struct vmestablish_gpadl {
	struct vmpacket_descriptor d;
	u32 gpadl;
	u32 range_cnt;
	struct gpa_range range[1];
} __packed;

/*
 * This is the format for a Teardown Gpadl packet, which indicates that the
 * GPADL handle in the Establish Gpadl packet will never be referenced again.
 */
struct vmteardown_gpadl {
	struct vmpacket_descriptor d;
	u32 gpadl;
	u32 reserved;	/* for alignment to a 8-byte boundary */
} __packed;

/*
 * This is the format for a GPA-Direct packet, which contains a set of GPA
 * ranges, in addition to commands and/or data.
 */
struct vmdata_gpa_direct {
	struct vmpacket_descriptor d;
	u32 reserved;
	u32 range_cnt;
	struct gpa_range range[1];
} __packed;

/* This is the format for a Additional Data Packet. */
struct vmadditional_data {
	struct vmpacket_descriptor d;
	u64 total_bytes;
	u32 offset;
	u32 byte_cnt;
	unsigned char data[1];
} __packed;

union vmpacket_largest_possible_header {
	struct vmpacket_descriptor simple_hdr;
	struct vmtransfer_page_packet_header xfer_page_hdr;
	struct vmgpadl_packet_header gpadl_hdr;
	struct vmadd_remove_transfer_page_set add_rm_xfer_page_hdr;
	struct vmestablish_gpadl establish_gpadl_hdr;
	struct vmteardown_gpadl teardown_gpadl_hdr;
	struct vmdata_gpa_direct data_gpa_direct_hdr;
};

#define VMPACKET_DATA_START_ADDRESS(__packet)	\
	(void *)(((unsigned char *)__packet) +	\
	 ((struct vmpacket_descriptor)__packet)->offset8 * 8)

#define VMPACKET_DATA_LENGTH(__packet)		\
	((((struct vmpacket_descriptor)__packet)->len8 -	\
	  ((struct vmpacket_descriptor)__packet)->offset8) * 8)

#define VMPACKET_TRANSFER_MODE(__packet)	\
	(((struct IMPACT)__packet)->type)

enum vmbus_packet_type {
	VM_PKT_INVALID				= 0x0,
	VM_PKT_SYNCH				= 0x1,
	VM_PKT_ADD_XFER_PAGESET			= 0x2,
	VM_PKT_RM_XFER_PAGESET			= 0x3,
	VM_PKT_ESTABLISH_GPADL			= 0x4,
	VM_PKT_TEARDOWN_GPADL			= 0x5,
	VM_PKT_DATA_INBAND			= 0x6,
	VM_PKT_DATA_USING_XFER_PAGES		= 0x7,
	VM_PKT_DATA_USING_GPADL			= 0x8,
	VM_PKT_DATA_USING_GPA_DIRECT		= 0x9,
	VM_PKT_CANCEL_REQUEST			= 0xa,
	VM_PKT_COMP				= 0xb,
	VM_PKT_DATA_USING_ADDITIONAL_PKT	= 0xc,
	VM_PKT_ADDITIONAL_DATA			= 0xd
};

#define VMBUS_DATA_PACKET_FLAG_COMPLETION_REQUESTED	1

/* Version 1 messages */
enum vmbus_channel_message_type {
	CHANNELMSG_INVALID			=  0,
	CHANNELMSG_OFFERCHANNEL		=  1,
	CHANNELMSG_RESCIND_CHANNELOFFER	=  2,
	CHANNELMSG_REQUESTOFFERS		=  3,
	CHANNELMSG_ALLOFFERS_DELIVERED	=  4,
	CHANNELMSG_OPENCHANNEL		=  5,
	CHANNELMSG_OPENCHANNEL_RESULT		=  6,
	CHANNELMSG_CLOSECHANNEL		=  7,
	CHANNELMSG_GPADL_HEADER		=  8,
	CHANNELMSG_GPADL_BODY			=  9,
	CHANNELMSG_GPADL_CREATED		= 10,
	CHANNELMSG_GPADL_TEARDOWN		= 11,
	CHANNELMSG_GPADL_TORNDOWN		= 12,
	CHANNELMSG_RELID_RELEASED		= 13,
	CHANNELMSG_INITIATE_CONTACT		= 14,
	CHANNELMSG_VERSION_RESPONSE		= 15,
	CHANNELMSG_UNLOAD			= 16,
	CHANNELMSG_UNLOAD_RESPONSE		= 17,
	CHANNELMSG_18				= 18,
	CHANNELMSG_19				= 19,
	CHANNELMSG_20				= 20,
	CHANNELMSG_TL_CONNECT_REQUEST		= 21,
	CHANNELMSG_COUNT
};

struct vmbus_channel_message_header {
	enum vmbus_channel_message_type msgtype;
	u32 padding;
} __packed;

/* Query VMBus Version parameters */
struct vmbus_channel_query_vmbus_version {
	struct vmbus_channel_message_header header;
	u32 version;
} __packed;

/* VMBus Version Supported parameters */
struct vmbus_channel_version_supported {
	struct vmbus_channel_message_header header;
	u8 version_supported;
} __packed;

/* Offer Channel parameters */
struct vmbus_channel_offer_channel {
	struct vmbus_channel_message_header header;
	struct vmbus_channel_offer offer;
	u32 child_relid;
	u8 monitorid;
	/*
	 * win7 and beyond splits this field into a bit field.
	 */
	u8 monitor_allocated:1;
	u8 reserved:7;
	/*
	 * These are new fields added in win7 and later.
	 * Do not access these fields without checking the
	 * negotiated protocol.
	 *
	 * If "is_dedicated_interrupt" is set, we must not set the
	 * associated bit in the channel bitmap while sending the
	 * interrupt to the host.
	 *
	 * connection_id is to be used in signaling the host.
	 */
	u16 is_dedicated_interrupt:1;
	u16 reserved1:15;
	u32 connection_id;
} __packed;

/* Rescind Offer parameters */
struct vmbus_channel_rescind_offer {
	struct vmbus_channel_message_header header;
	u32 child_relid;
} __packed;

/*
 * Request Offer -- no parameters, SynIC message contains the partition ID
 * Set Snoop -- no parameters, SynIC message contains the partition ID
 * Clear Snoop -- no parameters, SynIC message contains the partition ID
 * All Offers Delivered -- no parameters, SynIC message contains the partition
 *		           ID
 * Flush Client -- no parameters, SynIC message contains the partition ID
 */

/* Open Channel parameters */
struct vmbus_channel_open_channel {
	struct vmbus_channel_message_header header;

	/* Identifies the specific VMBus channel that is being opened. */
	u32 child_relid;

	/* ID making a particular open request at a channel offer unique. */
	u32 openid;

	/* GPADL for the channel's ring buffer. */
	u32 ringbuffer_gpadlhandle;

	/*
	 * Starting with win8, this field will be used to specify
	 * the target virtual processor on which to deliver the interrupt for
	 * the host to guest communication.
	 * Prior to win8, incoming channel interrupts would only
	 * be delivered on cpu 0. Setting this value to 0 would
	 * preserve the earlier behavior.
	 */
	u32 target_vp;

	/*
	* The upstream ring buffer begins at offset zero in the memory
	* described by RingBufferGpadlHandle. The downstream ring buffer
	* follows it at this offset (in pages).
	*/
	u32 downstream_ringbuffer_pageoffset;

	/* User-specific data to be passed along to the server endpoint. */
	unsigned char userdata[MAX_USER_DEFINED_BYTES];
} __packed;

/* Open Channel Result parameters */
struct vmbus_channel_open_result {
	struct vmbus_channel_message_header header;
	u32 child_relid;
	u32 openid;
	u32 status;
} __packed;

/* Close channel parameters; */
struct vmbus_channel_close_channel {
	struct vmbus_channel_message_header header;
	u32 child_relid;
} __packed;

/* Channel Message GPADL */
#define GPADL_TYPE_RING_BUFFER		1
#define GPADL_TYPE_SERVER_SAVE_AREA	2
#define GPADL_TYPE_TRANSACTION		8

/*
 * The number of PFNs in a GPADL message is defined by the number of
 * pages that would be spanned by ByteCount and ByteOffset.  If the
 * implied number of PFNs won't fit in this packet, there will be a
 * follow-up packet that contains more.
 */
struct vmbus_channel_gpadl_header {
	struct vmbus_channel_message_header header;
	u32 child_relid;
	u32 gpadl;
	u16 range_buflen;
	u16 rangecount;
	struct gpa_range range[0];
} __packed;

/* This is the followup packet that contains more PFNs. */
struct vmbus_channel_gpadl_body {
	struct vmbus_channel_message_header header;
	u32 msgnumber;
	u32 gpadl;
	u64 pfn[0];
} __packed;

struct vmbus_channel_gpadl_created {
	struct vmbus_channel_message_header header;
	u32 child_relid;
	u32 gpadl;
	u32 creation_status;
} __packed;

struct vmbus_channel_gpadl_teardown {
	struct vmbus_channel_message_header header;
	u32 child_relid;
	u32 gpadl;
} __packed;

struct vmbus_channel_gpadl_torndown {
	struct vmbus_channel_message_header header;
	u32 gpadl;
} __packed;

struct vmbus_channel_relid_released {
	struct vmbus_channel_message_header header;
	u32 child_relid;
} __packed;

struct vmbus_channel_initiate_contact {
	struct vmbus_channel_message_header header;
	u32 vmbus_version_requested;
	u32 target_vcpu; /* The VCPU the host should respond to */
	u64 interrupt_page;
	u64 monitor_page1;
	u64 monitor_page2;
} __packed;

/* Hyper-V socket: guest's connect()-ing to host */
struct vmbus_channel_tl_connect_request {
	struct vmbus_channel_message_header header;
	uuid_le guest_endpoint_id;
	uuid_le host_service_id;
} __packed;

struct vmbus_channel_version_response {
	struct vmbus_channel_message_header header;
	u8 version_supported;
} __packed;

enum vmbus_channel_state {
	CHANNEL_OFFER_STATE,
	CHANNEL_OPENING_STATE,
	CHANNEL_OPEN_STATE,
	CHANNEL_OPENED_STATE,
};

/*
 * Represents each channel msg on the vmbus connection This is a
 * variable-size data structure depending on the msg type itself
 */
struct vmbus_channel_msginfo {
	/* Bookkeeping stuff */
	struct list_head msglistentry;

	/* So far, this is only used to handle gpadl body message */
	struct list_head submsglist;

	/* Synchronize the request/response if needed */
	struct completion  waitevent;
	union {
		struct vmbus_channel_version_supported version_supported;
		struct vmbus_channel_open_result open_result;
		struct vmbus_channel_gpadl_torndown gpadl_torndown;
		struct vmbus_channel_gpadl_created gpadl_created;
		struct vmbus_channel_version_response version_response;
	} response;

	u32 msgsize;
	/*
	 * The channel message that goes out on the "wire".
	 * It will contain at minimum the VMBUS_CHANNEL_MESSAGE_HEADER header
	 */
	unsigned char msg[0];
};

struct vmbus_close_msg {
	struct vmbus_channel_msginfo info;
	struct vmbus_channel_close_channel msg;
};

/* Define connection identifier type. */
union hv_connection_id {
	u32 asu32;
	struct {
		u32 id:24;
		u32 reserved:8;
	} u;
};

/* Definition of the hv_signal_event hypercall input structure. */
struct hv_input_signal_event {
	union hv_connection_id connectionid;
	u16 flag_number;
	u16 rsvdz;
};

struct hv_input_signal_event_buffer {
	u64 align8;
	struct hv_input_signal_event event;
};

enum hv_signal_policy {
	HV_SIGNAL_POLICY_DEFAULT = 0,
	HV_SIGNAL_POLICY_EXPLICIT,
};

enum vmbus_device_type {
	HV_IDE = 0,
	HV_SCSI,
	HV_FC,
	HV_NIC,
	HV_ND,
	HV_PCIE,
	HV_FB,
	HV_KBD,
	HV_MOUSE,
	HV_KVP,
	HV_TS,
	HV_HB,
	HV_SHUTDOWN,
	HV_FCOPY,
	HV_BACKUP,
	HV_DM,
	HV_UNKOWN,
};

struct vmbus_device {
	u16  dev_type;
	uuid_le guid;
	bool perf_device;
};

struct vmbus_channel {
	/* Unique channel id */
	int id;

	struct list_head listentry;

	struct hv_device *device_obj;

	enum vmbus_channel_state state;

	struct vmbus_channel_offer_channel offermsg;
	/*
	 * These are based on the OfferMsg.MonitorId.
	 * Save it here for easy access.
	 */
	u8 monitor_grp;
	u8 monitor_bit;

	bool rescind; /* got rescind msg */

	u32 ringbuffer_gpadlhandle;

	/* Allocated memory for ring buffer */
	void *ringbuffer_pages;
	u32 ringbuffer_pagecount;
	struct hv_ring_buffer_info outbound;	/* send to parent */
	struct hv_ring_buffer_info inbound;	/* receive from parent */
	spinlock_t inbound_lock;

	struct vmbus_close_msg close_msg;

	/* Channel callback are invoked in this workqueue context */
	/* HANDLE dataWorkQueue; */

	void (*onchannel_callback)(void *context);
	void *channel_callback_context;

	/*
	 * A channel can be marked for efficient (batched)
	 * reading:
	 * If batched_reading is set to "true", we read until the
	 * channel is empty and hold off interrupts from the host
	 * during the entire read process.
	 * If batched_reading is set to "false", the client is not
	 * going to perform batched reading.
	 *
	 * By default we will enable batched reading; specific
	 * drivers that don't want this behavior can turn it off.
	 */

	bool batched_reading;

	bool is_dedicated_interrupt;
	struct hv_input_signal_event_buffer sig_buf;
	struct hv_input_signal_event *sig_event;

	/*
	 * Starting with win8, this field will be used to specify
	 * the target virtual processor on which to deliver the interrupt for
	 * the host to guest communication.
	 * Prior to win8, incoming channel interrupts would only
	 * be delivered on cpu 0. Setting this value to 0 would
	 * preserve the earlier behavior.
	 */
	u32 target_vp;
	/* The corresponding CPUID in the guest */
	u32 target_cpu;
	/*
	 * State to manage the CPU affiliation of channels.
	 */
	struct cpumask alloced_cpus_in_node;
	int numa_node;
	/*
	 * Support for sub-channels. For high performance devices,
	 * it will be useful to have multiple sub-channels to support
	 * a scalable communication infrastructure with the host.
	 * The support for sub-channels is implemented as an extention
	 * to the current infrastructure.
	 * The initial offer is considered the primary channel and this
	 * offer message will indicate if the host supports sub-channels.
	 * The guest is free to ask for sub-channels to be offerred and can
	 * open these sub-channels as a normal "primary" channel. However,
	 * all sub-channels will have the same type and instance guids as the
	 * primary channel. Requests sent on a given channel will result in a
	 * response on the same channel.
	 */

	/*
	 * Sub-channel creation callback. This callback will be called in
	 * process context when a sub-channel offer is received from the host.
	 * The guest can open the sub-channel in the context of this callback.
	 */
	void (*sc_creation_callback)(struct vmbus_channel *new_sc);

	/*
	 * Channel rescind callback. Some channels (the hvsock ones), need to
	 * register a callback which is invoked in vmbus_onoffer_rescind().
	 */
	void (*chn_rescind_callback)(struct vmbus_channel *channel);

	/*
	 * The spinlock to protect the structure. It is being used to protect
	 * test-and-set access to various attributes of the structure as well
	 * as all sc_list operations.
	 */
	spinlock_t lock;
	/*
	 * All Sub-channels of a primary channel are linked here.
	 */
	struct list_head sc_list;
	/*
	 * Current number of sub-channels.
	 */
	int num_sc;
	/*
	 * Number of a sub-channel (position within sc_list) which is supposed
	 * to be used as the next outgoing channel.
	 */
	int next_oc;
	/*
	 * The primary channel this sub-channel belongs to.
	 * This will be NULL for the primary channel.
	 */
	struct vmbus_channel *primary_channel;
	/*
	 * Support per-channel state for use by vmbus drivers.
	 */
	void *per_channel_state;
	/*
	 * To support per-cpu lookup mapping of relid to channel,
	 * link up channels based on their CPU affinity.
	 */
	struct list_head percpu_list;
	/*
	 * Host signaling policy: The default policy will be
	 * based on the ring buffer state. We will also support
	 * a policy where the client driver can have explicit
	 * signaling control.
	 */
	enum hv_signal_policy  signal_policy;
	/*
	 * On the channel send side, many of the VMBUS
	 * device drivers explicity serialize access to the
	 * outgoing ring buffer. Give more control to the
	 * VMBUS device drivers in terms how to serialize
	 * accesss to the outgoing ring buffer.
	 * The default behavior will be to aquire the
	 * ring lock to preserve the current behavior.
	 */
	bool acquire_ring_lock;

};

static inline void set_channel_lock_state(struct vmbus_channel *c, bool state)
{
	c->acquire_ring_lock = state;
}

static inline bool is_hvsock_channel(const struct vmbus_channel *c)
{
	return !!(c->offermsg.offer.chn_flags &
		  VMBUS_CHANNEL_TLNPI_PROVIDER_OFFER);
}

static inline void set_channel_signal_state(struct vmbus_channel *c,
					    enum hv_signal_policy policy)
{
	c->signal_policy = policy;
}

static inline void set_channel_read_state(struct vmbus_channel *c, bool state)
{
	c->batched_reading = state;
}

static inline void set_per_channel_state(struct vmbus_channel *c, void *s)
{
	c->per_channel_state = s;
}

static inline void *get_per_channel_state(struct vmbus_channel *c)
{
	return c->per_channel_state;
}

static inline void set_channel_pending_send_size(struct vmbus_channel *c,
						 u32 size)
{
	c->outbound.ring_buffer->pending_send_sz = size;
}

void vmbus_onmessage(void *context);

int vmbus_request_offers(void);

/*
 * APIs for managing sub-channels.
 */

void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel,
			void (*sc_cr_cb)(struct vmbus_channel *new_sc));

void vmbus_set_chn_rescind_callback(struct vmbus_channel *channel,
		void (*chn_rescind_cb)(struct vmbus_channel *));

/*
 * Retrieve the (sub) channel on which to send an outgoing request.
 * When a primary channel has multiple sub-channels, we choose a
 * channel whose VCPU binding is closest to the VCPU on which
 * this call is being made.
 */
struct vmbus_channel *vmbus_get_outgoing_channel(struct vmbus_channel *primary);

/*
 * Check if sub-channels have already been offerred. This API will be useful
 * when the driver is unloaded after establishing sub-channels. In this case,
 * when the driver is re-loaded, the driver would have to check if the
 * subchannels have already been established before attempting to request
 * the creation of sub-channels.
 * This function returns TRUE to indicate that subchannels have already been
 * created.
 * This function should be invoked after setting the callback function for
 * sub-channel creation.
 */
bool vmbus_are_subchannels_present(struct vmbus_channel *primary);

/* The format must be the same as struct vmdata_gpa_direct */
struct vmbus_channel_packet_page_buffer {
	u16 type;
	u16 dataoffset8;
	u16 length8;
	u16 flags;
	u64 transactionid;
	u32 reserved;
	u32 rangecount;
	struct hv_page_buffer range[MAX_PAGE_BUFFER_COUNT];
} __packed;

/* The format must be the same as struct vmdata_gpa_direct */
struct vmbus_channel_packet_multipage_buffer {
	u16 type;
	u16 dataoffset8;
	u16 length8;
	u16 flags;
	u64 transactionid;
	u32 reserved;
	u32 rangecount;		/* Always 1 in this case */
	struct hv_multipage_buffer range;
} __packed;

/* The format must be the same as struct vmdata_gpa_direct */
struct vmbus_packet_mpb_array {
	u16 type;
	u16 dataoffset8;
	u16 length8;
	u16 flags;
	u64 transactionid;
	u32 reserved;
	u32 rangecount;         /* Always 1 in this case */
	struct hv_mpb_array range;
} __packed;

extern int vmbus_open(struct vmbus_channel *channel,
			    u32 send_ringbuffersize,
			    u32 recv_ringbuffersize,
			    void *userdata,
			    u32 userdatalen,
			    void(*onchannel_callback)(void *context),
			    void *context);

extern void vmbus_close(struct vmbus_channel *channel);

extern int vmbus_sendpacket(struct vmbus_channel *channel,
				  void *buffer,
				  u32 bufferLen,
				  u64 requestid,
				  enum vmbus_packet_type type,
				  u32 flags);

extern int vmbus_sendpacket_ctl(struct vmbus_channel *channel,
				  void *buffer,
				  u32 bufferLen,
				  u64 requestid,
				  enum vmbus_packet_type type,
				  u32 flags,
				  bool kick_q);

extern int vmbus_sendpacket_pagebuffer(struct vmbus_channel *channel,
					    struct hv_page_buffer pagebuffers[],
					    u32 pagecount,
					    void *buffer,
					    u32 bufferlen,
					    u64 requestid);

extern int vmbus_sendpacket_pagebuffer_ctl(struct vmbus_channel *channel,
					   struct hv_page_buffer pagebuffers[],
					   u32 pagecount,
					   void *buffer,
					   u32 bufferlen,
					   u64 requestid,
					   u32 flags,
					   bool kick_q);

extern int vmbus_sendpacket_multipagebuffer(struct vmbus_channel *channel,
					struct hv_multipage_buffer *mpb,
					void *buffer,
					u32 bufferlen,
					u64 requestid);

extern int vmbus_sendpacket_mpb_desc(struct vmbus_channel *channel,
				     struct vmbus_packet_mpb_array *mpb,
				     u32 desc_size,
				     void *buffer,
				     u32 bufferlen,
				     u64 requestid);

extern int vmbus_establish_gpadl(struct vmbus_channel *channel,
				      void *kbuffer,
				      u32 size,
				      u32 *gpadl_handle);

extern int vmbus_teardown_gpadl(struct vmbus_channel *channel,
				     u32 gpadl_handle);

extern int vmbus_recvpacket(struct vmbus_channel *channel,
				  void *buffer,
				  u32 bufferlen,
				  u32 *buffer_actual_len,
				  u64 *requestid);

extern int vmbus_recvpacket_raw(struct vmbus_channel *channel,
				     void *buffer,
				     u32 bufferlen,
				     u32 *buffer_actual_len,
				     u64 *requestid);

extern void vmbus_ontimer(unsigned long data);

/* Base driver object */
struct hv_driver {
	const char *name;

	/*
	 * A hvsock offer, which has a VMBUS_CHANNEL_TLNPI_PROVIDER_OFFER
	 * channel flag, actually doesn't mean a synthetic device because the
	 * offer's if_type/if_instance can change for every new hvsock
	 * connection.
	 *
	 * However, to facilitate the notification of new-offer/rescind-offer
	 * from vmbus driver to hvsock driver, we can handle hvsock offer as
	 * a special vmbus device, and hence we need the below flag to
	 * indicate if the driver is the hvsock driver or not: we need to
	 * specially treat the hvosck offer & driver in vmbus_match().
	 */
	bool hvsock;

	/* the device type supported by this driver */
	uuid_le dev_type;
	const struct hv_vmbus_device_id *id_table;

	struct device_driver driver;

	int (*probe)(struct hv_device *, const struct hv_vmbus_device_id *);
	int (*remove)(struct hv_device *);
	void (*shutdown)(struct hv_device *);

};

/* Base device object */
struct hv_device {
	/* the device type id of this device */
	uuid_le dev_type;

	/* the device instance id of this device */
	uuid_le dev_instance;
	u16 vendor_id;
	u16 device_id;

	struct device device;

	struct vmbus_channel *channel;
};

static inline struct hv_device *device_to_hv_device(struct device *d)
{
	return container_of(d, struct hv_device, device);
}

static inline struct hv_driver *drv_to_hv_drv(struct device_driver *d)
{
	return container_of(d, struct hv_driver, driver);
}

static inline void hv_set_drvdata(struct hv_device *dev, void *data)
{
	dev_set_drvdata(&dev->device, data);
}

static inline void *hv_get_drvdata(struct hv_device *dev)
{
	return dev_get_drvdata(&dev->device);
}

/* Vmbus interface */
#define vmbus_driver_register(driver)	\
	__vmbus_driver_register(driver, THIS_MODULE, KBUILD_MODNAME)
int __must_check __vmbus_driver_register(struct hv_driver *hv_driver,
					 struct module *owner,
					 const char *mod_name);
void vmbus_driver_unregister(struct hv_driver *hv_driver);

void vmbus_hvsock_device_unregister(struct vmbus_channel *channel);

int vmbus_allocate_mmio(struct resource **new, struct hv_device *device_obj,
			resource_size_t min, resource_size_t max,
			resource_size_t size, resource_size_t align,
			bool fb_overlap_ok);
void vmbus_free_mmio(resource_size_t start, resource_size_t size);
int vmbus_cpu_number_to_vp_number(int cpu_number);
u64 hv_do_hypercall(u64 control, void *input, void *output);

/*
 * GUID definitions of various offer types - services offered to the guest.
 */

/*
 * Network GUID
 * {f8615163-df3e-46c5-913f-f2d2f965ed0e}
 */
#define HV_NIC_GUID \
	.guid = UUID_LE(0xf8615163, 0xdf3e, 0x46c5, 0x91, 0x3f, \
			0xf2, 0xd2, 0xf9, 0x65, 0xed, 0x0e)

/*
 * IDE GUID
 * {32412632-86cb-44a2-9b5c-50d1417354f5}
 */
#define HV_IDE_GUID \
	.guid = UUID_LE(0x32412632, 0x86cb, 0x44a2, 0x9b, 0x5c, \
			0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5)

/*
 * SCSI GUID
 * {ba6163d9-04a1-4d29-b605-72e2ffb1dc7f}
 */
#define HV_SCSI_GUID \
	.guid = UUID_LE(0xba6163d9, 0x04a1, 0x4d29, 0xb6, 0x05, \
			0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f)

/*
 * Shutdown GUID
 * {0e0b6031-5213-4934-818b-38d90ced39db}
 */
#define HV_SHUTDOWN_GUID \
	.guid = UUID_LE(0x0e0b6031, 0x5213, 0x4934, 0x81, 0x8b, \
			0x38, 0xd9, 0x0c, 0xed, 0x39, 0xdb)

/*
 * Time Synch GUID
 * {9527E630-D0AE-497b-ADCE-E80AB0175CAF}
 */
#define HV_TS_GUID \
	.guid = UUID_LE(0x9527e630, 0xd0ae, 0x497b, 0xad, 0xce, \
			0xe8, 0x0a, 0xb0, 0x17, 0x5c, 0xaf)

/*
 * Heartbeat GUID
 * {57164f39-9115-4e78-ab55-382f3bd5422d}
 */
#define HV_HEART_BEAT_GUID \
	.guid = UUID_LE(0x57164f39, 0x9115, 0x4e78, 0xab, 0x55, \
			0x38, 0x2f, 0x3b, 0xd5, 0x42, 0x2d)

/*
 * KVP GUID
 * {a9a0f4e7-5a45-4d96-b827-8a841e8c03e6}
 */
#define HV_KVP_GUID \
	.guid = UUID_LE(0xa9a0f4e7, 0x5a45, 0x4d96, 0xb8, 0x27, \
			0x8a, 0x84, 0x1e, 0x8c, 0x03, 0xe6)

/*
 * Dynamic memory GUID
 * {525074dc-8985-46e2-8057-a307dc18a502}
 */
#define HV_DM_GUID \
	.guid = UUID_LE(0x525074dc, 0x8985, 0x46e2, 0x80, 0x57, \
			0xa3, 0x07, 0xdc, 0x18, 0xa5, 0x02)

/*
 * Mouse GUID
 * {cfa8b69e-5b4a-4cc0-b98b-8ba1a1f3f95a}
 */
#define HV_MOUSE_GUID \
	.guid = UUID_LE(0xcfa8b69e, 0x5b4a, 0x4cc0, 0xb9, 0x8b, \
			0x8b, 0xa1, 0xa1, 0xf3, 0xf9, 0x5a)

/*
 * Keyboard GUID
 * {f912ad6d-2b17-48ea-bd65-f927a61c7684}
 */
#define HV_KBD_GUID \
	.guid = UUID_LE(0xf912ad6d, 0x2b17, 0x48ea, 0xbd, 0x65, \
			0xf9, 0x27, 0xa6, 0x1c, 0x76, 0x84)

/*
 * VSS (Backup/Restore) GUID
 */
#define HV_VSS_GUID \
	.guid = UUID_LE(0x35fa2e29, 0xea23, 0x4236, 0x96, 0xae, \
			0x3a, 0x6e, 0xba, 0xcb, 0xa4, 0x40)
/*
 * Synthetic Video GUID
 * {DA0A7802-E377-4aac-8E77-0558EB1073F8}
 */
#define HV_SYNTHVID_GUID \
	.guid = UUID_LE(0xda0a7802, 0xe377, 0x4aac, 0x8e, 0x77, \
			0x05, 0x58, 0xeb, 0x10, 0x73, 0xf8)

/*
 * Synthetic FC GUID
 * {2f9bcc4a-0069-4af3-b76b-6fd0be528cda}
 */
#define HV_SYNTHFC_GUID \
	.guid = UUID_LE(0x2f9bcc4a, 0x0069, 0x4af3, 0xb7, 0x6b, \
			0x6f, 0xd0, 0xbe, 0x52, 0x8c, 0xda)

/*
 * Guest File Copy Service
 * {34D14BE3-DEE4-41c8-9AE7-6B174977C192}
 */

#define HV_FCOPY_GUID \
	.guid = UUID_LE(0x34d14be3, 0xdee4, 0x41c8, 0x9a, 0xe7, \
			0x6b, 0x17, 0x49, 0x77, 0xc1, 0x92)

/*
 * NetworkDirect. This is the guest RDMA service.
 * {8c2eaf3d-32a7-4b09-ab99-bd1f1c86b501}
 */
#define HV_ND_GUID \
	.guid = UUID_LE(0x8c2eaf3d, 0x32a7, 0x4b09, 0xab, 0x99, \
			0xbd, 0x1f, 0x1c, 0x86, 0xb5, 0x01)

/*
 * PCI Express Pass Through
 * {44C4F61D-4444-4400-9D52-802E27EDE19F}
 */

#define HV_PCIE_GUID \
	.guid = UUID_LE(0x44c4f61d, 0x4444, 0x4400, 0x9d, 0x52, \
			0x80, 0x2e, 0x27, 0xed, 0xe1, 0x9f)

/*
 * Common header for Hyper-V ICs
 */

#define ICMSGTYPE_NEGOTIATE		0
#define ICMSGTYPE_HEARTBEAT		1
#define ICMSGTYPE_KVPEXCHANGE		2
#define ICMSGTYPE_SHUTDOWN		3
#define ICMSGTYPE_TIMESYNC		4
#define ICMSGTYPE_VSS			5

#define ICMSGHDRFLAG_TRANSACTION	1
#define ICMSGHDRFLAG_REQUEST		2
#define ICMSGHDRFLAG_RESPONSE		4

/*
 * While we want to handle util services as regular devices,
 * there is only one instance of each of these services; so
 * we statically allocate the service specific state.
 */

struct hv_util_service {
	u8 *recv_buffer;
	void *channel;
	void (*util_cb)(void *);
	int (*util_init)(struct hv_util_service *);
	void (*util_deinit)(void);
};

struct vmbuspipe_hdr {
	u32 flags;
	u32 msgsize;
} __packed;

struct ic_version {
	u16 major;
	u16 minor;
} __packed;

struct icmsg_hdr {
	struct ic_version icverframe;
	u16 icmsgtype;
	struct ic_version icvermsg;
	u16 icmsgsize;
	u32 status;
	u8 ictransaction_id;
	u8 icflags;
	u8 reserved[2];
} __packed;

struct icmsg_negotiate {
	u16 icframe_vercnt;
	u16 icmsg_vercnt;
	u32 reserved;
	struct ic_version icversion_data[1]; /* any size array */
} __packed;

struct shutdown_msg_data {
	u32 reason_code;
	u32 timeout_seconds;
	u32 flags;
	u8  display_message[2048];
} __packed;

struct heartbeat_msg_data {
	u64 seq_num;
	u32 reserved[8];
} __packed;

/* Time Sync IC defs */
#define ICTIMESYNCFLAG_PROBE	0
#define ICTIMESYNCFLAG_SYNC	1
#define ICTIMESYNCFLAG_SAMPLE	2

#ifdef __x86_64__
#define WLTIMEDELTA	116444736000000000L	/* in 100ns unit */
#else
#define WLTIMEDELTA	116444736000000000LL
#endif

struct ictimesync_data {
	u64 parenttime;
	u64 childtime;
	u64 roundtriptime;
	u8 flags;
} __packed;

struct hyperv_service_callback {
	u8 msg_type;
	char *log_msg;
	uuid_le data;
	struct vmbus_channel *channel;
	void (*callback) (void *context);
};

#define MAX_SRV_VER	0x7ffffff
extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *,
					struct icmsg_negotiate *, u8 *, int,
					int);

void hv_process_channel_removal(struct vmbus_channel *channel, u32 relid);

/*
 * Negotiated version with the Host.
 */

extern __u32 vmbus_proto_version;

int vmbus_send_tl_connect_request(const uuid_le *shv_guest_servie_id,
				  const uuid_le *shv_host_servie_id);
void vmbus_set_event(struct vmbus_channel *channel);

/* Get the start of the ring buffer. */
static inline void *
hv_get_ring_buffer(struct hv_ring_buffer_info *ring_info)
{
	return (void *)ring_info->ring_buffer->buffer;
}

/*
 * To optimize the flow management on the send-side,
 * when the sender is blocked because of lack of
 * sufficient space in the ring buffer, potential the
 * consumer of the ring buffer can signal the producer.
 * This is controlled by the following parameters:
 *
 * 1. pending_send_sz: This is the size in bytes that the
 *    producer is trying to send.
 * 2. The feature bit feat_pending_send_sz set to indicate if
 *    the consumer of the ring will signal when the ring
 *    state transitions from being full to a state where
 *    there is room for the producer to send the pending packet.
 */

static inline  bool hv_need_to_signal_on_read(struct hv_ring_buffer_info *rbi)
{
	u32 cur_write_sz;
	u32 pending_sz;

	/*
	 * Issue a full memory barrier before making the signaling decision.
	 * Here is the reason for having this barrier:
	 * If the reading of the pend_sz (in this function)
	 * were to be reordered and read before we commit the new read
	 * index (in the calling function)  we could
	 * have a problem. If the host were to set the pending_sz after we
	 * have sampled pending_sz and go to sleep before we commit the
	 * read index, we could miss sending the interrupt. Issue a full
	 * memory barrier to address this.
	 */
	virt_mb();

	pending_sz = READ_ONCE(rbi->ring_buffer->pending_send_sz);
	/* If the other end is not blocked on write don't bother. */
	if (pending_sz == 0)
		return false;

	cur_write_sz = hv_get_bytes_to_write(rbi);

	if (cur_write_sz >= pending_sz)
		return true;

	return false;
}

/*
 * An API to support in-place processing of incoming VMBUS packets.
 */
#define VMBUS_PKT_TRAILER	8

static inline struct vmpacket_descriptor *
get_next_pkt_raw(struct vmbus_channel *channel)
{
	struct hv_ring_buffer_info *ring_info = &channel->inbound;
	u32 read_loc = ring_info->priv_read_index;
	void *ring_buffer = hv_get_ring_buffer(ring_info);
	struct vmpacket_descriptor *cur_desc;
	u32 packetlen;
	u32 dsize = ring_info->ring_datasize;
	u32 delta = read_loc - ring_info->ring_buffer->read_index;
	u32 bytes_avail_toread = (hv_get_bytes_to_read(ring_info) - delta);

	if (bytes_avail_toread < sizeof(struct vmpacket_descriptor))
		return NULL;

	if ((read_loc + sizeof(*cur_desc)) > dsize)
		return NULL;

	cur_desc = ring_buffer + read_loc;
	packetlen = cur_desc->len8 << 3;

	/*
	 * If the packet under consideration is wrapping around,
	 * return failure.
	 */
	if ((read_loc + packetlen + VMBUS_PKT_TRAILER) > (dsize - 1))
		return NULL;

	return cur_desc;
}

/*
 * A helper function to step through packets "in-place"
 * This API is to be called after each successful call
 * get_next_pkt_raw().
 */
static inline void put_pkt_raw(struct vmbus_channel *channel,
				struct vmpacket_descriptor *desc)
{
	struct hv_ring_buffer_info *ring_info = &channel->inbound;
	u32 read_loc = ring_info->priv_read_index;
	u32 packetlen = desc->len8 << 3;
	u32 dsize = ring_info->ring_datasize;

	if ((read_loc + packetlen + VMBUS_PKT_TRAILER) > dsize)
		BUG();
	/*
	 * Include the packet trailer.
	 */
	ring_info->priv_read_index += packetlen + VMBUS_PKT_TRAILER;
}

/*
 * This call commits the read index and potentially signals the host.
 * Here is the pattern for using the "in-place" consumption APIs:
 *
 * while (get_next_pkt_raw() {
 *	process the packet "in-place";
 *	put_pkt_raw();
 * }
 * if (packets processed in place)
 *	commit_rd_index();
 */
static inline void commit_rd_index(struct vmbus_channel *channel)
{
	struct hv_ring_buffer_info *ring_info = &channel->inbound;
	/*
	 * Make sure all reads are done before we update the read index since
	 * the writer may start writing to the read area once the read index
	 * is updated.
	 */
	virt_rmb();
	ring_info->ring_buffer->read_index = ring_info->priv_read_index;

	if (hv_need_to_signal_on_read(ring_info))
		vmbus_set_event(channel);
}

#endif /* _HYPERV_H */


text:
require "awesome_form_bootstrap/engine"

module AwesomeFormBootstrap
end


text:
package org.webcurator.auth.tag;

import java.util.HashMap;

import javax.servlet.jsp.JspException;
import javax.servlet.jsp.tagext.TagSupport;

import org.webcurator.auth.AuthorityManager;
import org.webcurator.auth.AuthorityManagerImpl;
import org.webcurator.core.util.AuthUtil;
import org.webcurator.domain.model.auth.RolePrivilege;
import org.webcurator.domain.model.auth.User;

/**
 * The authority:noPrivilege tag is used to display sections of a page
 * where the user doesn't have a specified Privilege.
 * This tag can be used in combination with the authority:hasPrivilege tag
 * similar to the c:choose c:otherwise tags provided by the core tag library.
 * @author BPrice
 */
public class NoPrivilegeTag extends TagSupport {

    private static final long serialVersionUID = 8379450274642156262L;

    private String privilege = null;
    private int scope = 1000;
    private AuthorityManager authorityManager = new AuthorityManagerImpl();

    @Override
    public int doStartTag() throws JspException {
        User user = AuthUtil.getRemoteUserObject();
        HashMap privs = authorityManager.getPrivilegesForUser(user);
        if (privs.containsKey(getPrivilege())) {
            RolePrivilege rp = (RolePrivilege)privs.get(getPrivilege());
            int usersPrivScope = rp.getPrivilegeScope();
            if (usersPrivScope <= getScope()) {
                return TagSupport.SKIP_BODY;
            }
        }
        return TagSupport.EVAL_BODY_INCLUDE;
    }

    @Override
    public int doEndTag() throws JspException {
        return TagSupport.EVAL_PAGE;
    }

    public String getPrivilege() {
        return privilege;
    }

    public void setPrivilege(String privilege) {
        this.privilege = privilege;
    }

    public int getScope() {
        return scope;
    }

    public void setScope(int scope) {
        this.scope = scope;
    }

}


text:
"""Selects the appropriate scraper for Chrome."""

__author__ = 'jhaas@google.com (Jonathan Haas)'

def GetScraper(version):
  """Returns the scraper module for the given version.

  Args:
    version: version string of Chrome, or None for most recent

  Returns:
    scrape module for given version
  """
  if version is None:
    version = "0.1.101.0"

  parsed_version = [int(x) for x in version.split(".")]

  if (parsed_version[0] > 0 or
      parsed_version[1] > 1 or
      parsed_version[2] > 97 or
      parsed_version[3] > 0):
    scraper_version = "chrome011010"
  else:
    scraper_version = "chrome01970"

  return __import__(scraper_version, globals(), locals(), [''])

# if invoked rather than imported, test
if __name__ == "__main__":
  version = "0.1.101.0"

  print GetScraper(version).version


text:
/**
 * Add zero in front of numbers < 10
 * @param {number} i
 */
export function zeroPad(i) {
  if (i < 10) {
    i = "0" + i;
  }
  return i;
}

/**
 * Find the friendly name for a weather conditionCode.
 * @param {*} conditionCode
 * @returns
 */
export function findWeatherConditionName(WeatherCondition, conditionCode) {
  for (const condition of Object.keys(WeatherCondition)) {
    if (conditionCode === WeatherCondition[condition]) return condition;
  }
}

/**
* Convert Celsius to Fahrenheit
* @param {object} data - WeatherData -
*/
export function toFahrenheit(data) {
  if (data.unit.toLowerCase() === "celsius") {
     data.temperature =  Math.round((data.temperature * 1.8)+32);
     data.unit = "Fahrenheit";
  }

  return data
}


text:
'use strict';
import {SectionList_inverted} from './SectionListExamples';
const React = require('react');

exports.title = 'SectionList inverted';
exports.testTitle = 'Test inverted prop';
exports.category = 'ListView';
exports.documentationURL = 'https://reactnative.dev/docs/sectionlist';
exports.description = 'Toggle inverted to see list inverted.';
exports.examples = [
  {
    title: 'SectionList inverted',
    render: function(): React.Element<typeof SectionList_inverted> {
      return <SectionList_inverted />;
    },
  },
];


text:
void mcCmdGet::help(void) {
  cout << "  Usage: get [> file]" << endl;
  cout << "  Option:" << endl;
  cout << "    posts GET request to the server." << endl;
  cout << "    > operator redirects the response body to the file if "
          "there is any." << endl;
  cout << "    list has headers for the request. Default list is defhdr."
       << endl;
}

mcLanguageState mcCmdGet::parse(mcScanner& scanner, mcIPerformer* performer) {
  string path;
  mcToken token = scanner.tokenize();
  if (token.id == MC_TOKEN_GT) {
    token = scanner.tokenize();
    if (token.id == MC_TOKEN_STRING) {
      path = token.buffer;
    } else {
      cerr << "file path is missing" << endl;
      return MC_LANG_CONTINUE;
    }
    token = scanner.tokenize();
  }
  if (token.id != MC_TOKEN_EOL) {
    cerr << "invalid argument " << token.buffer << endl;
    return MC_LANG_CONTINUE;
  }
  try {
    performer->get(path);
  }
  catch (exception & e) {
    cerr << e.what() << endl;
  }
  return MC_LANG_CONTINUE;
}


text:
package com.action.gaobingfachenxusheji.chapter05.aio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class AIOEchoServer {

    public final static int PORT = 8000;

    private AsynchronousServerSocketChannel server;

    public AIOEchoServer() throws IOException {

        server = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(PORT));

    }

    public void start() {
        System.out.println("Server listen on " + PORT);

        // 注册事件和事件完成后的处理
        server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {

            final ByteBuffer buffer = ByteBuffer.allocate(1024);

            @Override
            public void completed(AsynchronousSocketChannel result, Object attachment) {
                System.out.println(Thread.currentThread().getName());
                Future<Integer> writeResult = null;
                try {
                    buffer.clear();
                    result.read(buffer).get(100, TimeUnit.SECONDS);
                    buffer.flip();
                    writeResult = result.write(buffer);
                } catch (InterruptedException | ExecutionException | TimeoutException e) {
                    e.printStackTrace();
                    System.out.println(e.toString());
                } finally {
                    try {
                        server.accept(null, this);
                        writeResult.get();
                        result.close();
                    } catch (InterruptedException | ExecutionException | IOException e) {
                        e.printStackTrace();
                        System.out.println(e.toString());
                    }
                }

            }

            @Override
            public void failed(Throwable exc, Object attachment) {
                System.out.println("failed: " + exc);
            }
        });

    }

    public static void main(String[] args) throws IOException, InterruptedException {
        new AIOEchoServer().start();
        while (true) {
            Thread.sleep(100);
        }
    }
}


text:
import React from 'react';
import {Link} from 'react-router-dom';
import {Tooltip} from 'antd';
import {connect} from 'react-redux';
import HomeIcon from 'react-icons/lib/io/ios-home-outline';
import GithubIcon from 'react-icons/lib/io/social-github-outline';
import BackIcon from 'react-icons/lib/io/ios-arrow-back';

const About = ({theme}) => {
        return (

 A friend suggested I make a currency converter that ain't
                        <Tooltip placement="top" title="French for 'ugly'" arrowPointAtCenter>
                             moche.
                        </Tooltip>

                    I quickly realized that she's right: most currency converters are ugly af.

                    So I made a currency converter that a) ain't moche to begin with & b) allows you to style it as you see fit.

                    Enjoy.

                   <Tooltip placement="bottom" title="< Back" arrowPointAtCenter>
                    <Link to="/">
                        <BackIcon style={{color: theme.borderColor}} size={25}/>
                    </Link>
                   </Tooltip>

                    <Tooltip placement="bottom" title="Visit https://matthewphillips.io" arrowPointAtCenter>

                        <HomeIcon style={{color: theme.borderColor}} size={25}/>

                    </Tooltip>

                    <Tooltip placement="bottom" title="This app's repo @ github" arrowPointAtCenter>

                        <GithubIcon style={{color: theme.borderColor}} size={25}/>

                    </Tooltip>

        )
};

export default connect(state => ({theme: state.themes}))(About);


text:
var express = require('express');
var router = express.Router();
var multer = require('multer');
var db;
var sess;

router.get('/', function(req, res, next) {
    sess = req.session;
    db = req.db;
    if(sess && sess.username){
        db.collection(User_,function(err,collection){
            if(!err){
                collection.findOne({'username':sess.username},function(err,item){
                    if(!err){
                        res.render('myAccount',{ title : appName , user : item});
                    }else{
                        res.redirect(login);
                    }
                });
            }else{
                res.redirect(login);
            }
        });
    }else{
        res.redirect(login);
    }

});

router.post('/', function(req, res, next) {
    sess = req.session;
    db = req.db;
    if(sess && sess.username === req.body.txtUserName){
        db.collection(User_,function(err, collection){
            if(!err){
                collection.update({'username': sess.username},{ $set : {
                    email_id: req.body.txtEmailId,
                    ph_no: req.body.txtPhoneNumber,
                    first_name : req.body.txtFN,
                    last_name : req.body.txtLN
                },$currentDate: { modified_on: true }},function(err, item){
                    if(!err){
                        res.redirect(myaccount);
                    } else {
                        res.redirect(login);
                    }
                });
            }else{
                res.redirect(login);
            }
        });
    }else{
        res.redirect(login);
    }

});

var storage = multer.diskStorage({
    destination: './public/images/users',
    filename: function ( req, file, cb ) {
            var getFileExt = function(fileName){
                var fileExt = fileName.split(".");
                if( fileExt.length === 1 || ( fileExt[0] === "" && fileExt.length === 2 ) ) {
                    return "";
                }
                return fileExt.pop();
            }
            cb(null, sess.username+'.'+ getFileExt(file.originalname) );

    }
});

var upload = multer({ storage: storage });

router.post('/upload', upload.single('txtUserAvatar'), function(req, res, next) {
    sess = req.session;
    if(sess && sess.username){
        res.redirect(myaccount);
    }else{
        res.redirect(login);
    }

});

module.exports = router;


text:
PROJECT ARCHIVED AND NO LONGER MAINTAINED

py_multistatus
==============

Statusbar information script with configurable update intervals for each block of information. Designed for window managers using a separate bar such as LemonBoy's `bar <https://github.com/LemonBoy/bar>`_, Moetune's `some_sorta_bar <https://github.com/moetunes/Some_sorta_bar>`_ (TODO), or `dzen <https://github.com/robm/dzen>`_ (TODO). Information is generated and piped to the bar input. A configuration file is included, and plugins can easily be added if desired. Plugins (so far) include:

* Monsterwm desktop status display
* Date/time
* Load average
* New mail notifier for maildir(s) + weather display
* Disk usage warnings
* Battery status display
* Network up/down state and upload/download speed + OpenVPN status
* Music player status: MPD/Mopidy and Pianobar
* Current `Watson <http://tailordev.github.io/Watson/>`_ project

Idea and code based heavily on `py3status <https://github.com/kaszak/py3status>`_. Much thanks to kaskak, as I studied his code intensely before I started. I had no prior experience with threading/queue/fifo before starting this project!

Scott Hansen <firecat4153@gmail.com>

Features:
---------

* Python 3.x
* Use less CPU cycles for infrequently needed information updates
* Configurable for different statusbars (bar, some_sorta_bar, etc.)
* Easily add new plugins (see plugin_skel.py in the plugins directory).
* Includes a python monsterstart.py script to start monsterwm and pipe its desktop output to a FIFO for reading by py-multistatus.

Requires:
---------

* Python 3+
* psutil
* An installed statusbar (bar, some_sorta_bar, etc.)

Installation:
-------------

* `Archlinux AUR <link here>`_ (TODO)
* ``# python setup.py install``  OR
* ``$ python setup.py install --user`` OR
* ``pip install py_multistatus`` (TODO)

License:
--------

* MIT

Usage:
------

* Copy configuration file status.cfg from /usr/share/py-multistatus to ~/.config/py-multistatus and edit. Make sure the bar executable and all the formatting symbols are correct for the bar you are using.
* Ensure mail accounts and directories are correct. If you want the weather displayed while there are no mail notifications, create a text file ~/.weather with the weather add there however you like. The *top line* of the file will be displayed.
* Add ``multistatus &`` to ~/.xinitrc before the ``exec <windowmanager`` line (or before ``/path/to/monsterstart.py``)
* The bar is automatically started by ``multistatus``
* If using monsterstart.py, copy it someplace into your $PATH. It starts ``multistatus`` so use it in .xinitrc instead.

ISSUES:
-------

* Some stlarch font icons (higher numbers) cause problems with the display with 'bar'
* Network speed indicator occasionally crashes when switching networks.
* If the statusbar is killed and restarted manually, the monsterwm desktop info doesn't always immediately appear.

TODO:
-----

1. Test/add support for other bars beside LemonBoy's bar.
2. Add logging/error detection for threads. Possibly auto-restart crashed threads
3. Add option to periodically update the weather? (clickable bars only)
4. Volume indication. Maybe volume controls? (clickable bars only)
5. Possible inotify support for file-based information?
6. Investigate using concurrent.futures in place of threads/queues.


text:
// Template Source: Enum.java.tt
// ------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All Rights Reserved.  Licensed under the MIT License.  See License in the project root for license information.
// ------------------------------------------------------------------------------

package com.microsoft.graph.models;

/**
 * The Enum Provisioning Status Error Category.
*/
public enum ProvisioningStatusErrorCategory
{
    /**
    * failure
    */
    FAILURE,
    /**
    * non Service Failure
    */
    NON_SERVICE_FAILURE,
    /**
    * success
    */
    SUCCESS,
    /**
    * unknown Future Value
    */
    UNKNOWN_FUTURE_VALUE,
    /**
    * For ProvisioningStatusErrorCategory values that were not expected from the service
    */
    UNEXPECTED_VALUE
}


text:
<!doctype html>

    <title>Story Attribution</title>

    <link href="../../build/css/amp-story-player-v0.css" rel='stylesheet' type='text/css'>

    <meta name="viewport" content="width=device-width,minimum-scale=1,initial-scale=1">

Story Attribution

    <amp-story-player style="width: 360px; height: 600px;">

          A local's guide to what to eat and do in New York City

    </amp-story-player>


text:
using System.ComponentModel;

namespace LinqAn.Google.Dimensions
{
	/// <summary>
	/// 	The name of the requested custom dimension, where 102 refers the number/index of the custom dimension.
	/// </summary>
	[Description("The name of the requested custom dimension, where 102 refers the number/index of the custom dimension.")]
	public class Dimension102: Dimension
	{
		/// <summary>
		/// 	Instantiates a <seealso cref="Dimension102" />.
		/// </summary>
		public Dimension102(): base("Custom Dimension 102",true,"ga:dimension102")
		{

		}
	}
}


text:
package rule

import (
	"regexp"

	bzl "github.com/bazelbuild/buildtools/build"
)

// Directive is a key-value pair extracted from a top-level comment in
// a build file. Directives have the following format:
//
//     # gazelle:key value
//
// Keys may not contain spaces. Values may be empty and may contain spaces,
// but surrounding space is trimmed.
type Directive struct {
	Key, Value string
}

// TODO(jayconrod): annotation directives will apply to an individual rule.
// They must appear in the block of comments above that rule.

// ParseDirectives scans f for Gazelle directives. The full list of directives
// is returned. Errors are reported for unrecognized directives and directives
// out of place (after the first statement).
func ParseDirectives(f *bzl.File) []Directive {
	return parseDirectives(f.Stmt)
}

// ParseDirectivesFromMacro scans a macro body for Gazelle directives. The
// full list of directives is returned. Errors are reported for unrecognized
// directives and directives out of place (after the first statement).
func ParseDirectivesFromMacro(f *bzl.DefStmt) []Directive {
	return parseDirectives(f.Body)
}

func parseDirectives(stmt []bzl.Expr) []Directive {
	var directives []Directive
	parseComment := func(com bzl.Comment) {
		match := directiveRe.FindStringSubmatch(com.Token)
		if match == nil {
			return
		}
		key, value := match[1], match[2]
		directives = append(directives, Directive{key, value})
	}

	for _, s := range stmt {
		coms := s.Comment()
		for _, com := range coms.Before {
			parseComment(com)
		}
		for _, com := range coms.After {
			parseComment(com)
		}
	}
	return directives
}

var directiveRe = regexp.MustCompile(`^#\s*gazelle:(\w+)\s*(.*?)\s*$`)


text:
package threadcommunication;

public class RequestForSDKServiceData {

	public enum OperationName {listBucket,listObject,uploadObject,
		downloadOneObject,putOneFolder,deleteOneObject,getObjectMetaData};
	private OperationName operationName = null;
	String bucketName = "";
	String objectName = "";
	String absolutePath = "";
	//这个主要控制要不要刷新objecttable
	String oldKey = "";

	public RequestForSDKServiceData(OperationName operationName) {
		// TODO Auto-generated constructor stub
		this.operationName = operationName;
	}
	public RequestForSDKServiceData(OperationName operationName,String bucketName) {
		// TODO Auto-generated constructor stub
		this.operationName = operationName;
		this.bucketName = bucketName;
	}
	public RequestForSDKServiceData(OperationName operationName,String bucketName ,String objectName) {
		// TODO Auto-generated constructor stub
		this.operationName = operationName;
		this.bucketName = bucketName;
		this.objectName = objectName;
	}
	public RequestForSDKServiceData(OperationName operationName,String bucketName ,String objectName,String absolutePath) {
		// TODO Auto-generated constructor stub
		this.operationName = operationName;
		this.bucketName = bucketName;
		this.objectName = objectName;
		this.absolutePath = absolutePath;
	}
	public RequestForSDKServiceData(OperationName operationName,String bucketName ,String objectName,String absolutePath,String oldKey) {
		// TODO Auto-generated constructor stub
		this.operationName = operationName;
		this.bucketName = bucketName;
		this.objectName = objectName;
		this.absolutePath = absolutePath;
		this.oldKey = oldKey;
	}

	public OperationName getOperationName() {
		return operationName;
	}
	public String getBucketName() {
		return bucketName;
	}
	public String getObjectName() {
		return objectName;
	}
	public String getAbsolutePath() {
		return absolutePath;
	}
	public String getOldKey() {
		return oldKey;
	}

}