text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>citizensnips</groupId>
    <artifactId>Marshals</artifactId>
    <version>Shitgotreal v1.0</version>
    <name>Marshals</name>
    <description>Chest Restocking plugin</description>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.build.number>UNKNOWN</project.build.number>
    </properties>

    <repositories>
        <repository>
            <id>bukkit</id>
            <url>http://repo.bukkit.org/content/groups/public/</url>
        </repository>
        <repository>
            <id>onarandombox</id>
            <url>http://repo.onarandombox.com/content/groups/public/</url>
        </repository>
    </repositories>

    <pluginRepositories>
        <pluginRepository>
            <id>doodleproject-repo</id>
            <name>DoodleProject Maven 2 Repository</name>
            <url>http://doodleproject.sourceforge.net/maven2/release</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </pluginRepository>
    </pluginRepositories>

    <!-- Profiles are used to detect whether this is a local or Jenkins build
and adjust the build number accordingly -->
    <profiles>
        <profile>
            <id>jenkins</id>
            <activation>
                <property>
                    <name>env.BUILD_NUMBER</name>
                </property>
            </activation>
            <properties>
                <project.build.number>${env.BUILD_NUMBER}</project.build.number>
            </properties>
        </profile>
    </profiles>

    <build>
        <defaultGoal>clean package</defaultGoal>
        <plugins>
            <!-- Compiler -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.6</source>
                    <target>1.6</target>
                </configuration>
            </plugin>
            <!-- Jar Plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.3.1</version>
                <configuration>
                    <archive>
                        <manifestEntries>
                        </manifestEntries>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>com.google.code.maven-replacer-plugin</groupId>
                <artifactId>maven-replacer-plugin</artifactId>
                <version>1.3.8</version>
                <executions>
                    <execution>
                        <phase>prepare-package</phase>
                        <goals>
                            <goal>replace</goal>
                        </goals>
                    </execution>
                </executions>
                <configuration>
                    <file>target/classes/plugin.yml</file>
                    <replacements>
                        <replacement>
                            <token>maven-version-number</token>
                            <value>${project.version}-b${project.build.number}</value>
                        </replacement>
                    </replacements>
                </configuration>
            </plugin>
            <!-- Maven Source Plugin -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-source-plugin</artifactId>
                <version>2.1.2</version>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.11</version>
                <configuration>
                    <parallel>methods</parallel>
                    <threadCount>10</threadCount>
                    <excludes>
                        <exclude>**/TestCommandSender.java</exclude>
                        <exclude>**/TestInstanceCreator.java</exclude>
                    </excludes>
                </configuration>
                <dependencies>
                    <dependency>
                        <groupId>org.apache.maven.surefire</groupId>
                        <artifactId>surefire-junit47</artifactId>
                        <version>2.11</version>
                    </dependency>
                </dependencies>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-checkstyle-plugin</artifactId>
                <version>2.8</version>
                <configuration>
                    <enableRulesSummary>true</enableRulesSummary>
                    <configLocation>${project.basedir}/config/checks.xml</configLocation>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>1.5</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <artifactSet>
                                <includes>
                                    <include>com.dumptruckman.minecraft:BukkitPlugin</include>
                                </includes>
                            </artifactSet>
                            <relocations>
                                <relocation>
                                    <pattern>com.dumptruckman.minecraft.pluginbase</pattern>
                                    <shadedPattern>citizensnips.marshals.pluginbase</shadedPattern>
                                </relocation>
                            </relocations>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
    <dependencies>
        <!-- Bukkit Dependency -->
        <dependency>
            <groupId>org.bukkit</groupId>
            <artifactId>bukkit</artifactId>
            <version>1.2.5-R1.0</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        <!-- Bukkit Dependency -->
        <!-- Start of CommandHandler Dependency -->
        <dependency>
            <groupId>com.dumptruckman.minecraft</groupId>
            <artifactId>BukkitPlugin</artifactId>
            <version>1.2-SNAPSHOT</version>
            <type>jar</type>
            <scope>compile</scope>
        </dependency>
        <!-- End of CommandHandler Dependency -->
        <!-- Start of Test Dependencies -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.8.2</version>
        </dependency>
        <dependency>
            <groupId>org.powermock</groupId>
            <artifactId>powermock-module-junit4</artifactId>
            <version>1.4.9</version>
            <type>jar</type>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.powermock</groupId>
            <artifactId>powermock-api-easymock</artifactId>
            <version>1.4.9</version>
            <type>jar</type>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.powermock</groupId>
            <artifactId>powermock-api-mockito</artifactId>
            <version>1.4.9</version>
            <type>jar</type>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.easymock</groupId>
            <artifactId>easymock</artifactId>
            <version>3.0</version>
            <scope>test</scope>
        </dependency>
        <!-- End of Test Dependencies -->
    </dependencies>

    <distributionManagement>
        <repository>
            <id>OnARandomBox</id>
            <url>http://repo.onarandombox.com/content/repositories/thirdparty/</url>
        </repository>
        <snapshotRepository>
            <id>OnARandomBox</id>
            <url>http://repo.onarandombox.com/content/repositories/thirdparty-dev/</url>
        </snapshotRepository>
    </distributionManagement>
</project>


text:
package com.example.candatasender.main;

import java.io.*;
import java.util.*;
import java.text.SimpleDateFormat;
import java.text.ParsePosition;
import android.os.AsyncTask;
import android.app.ProgressDialog;
import android.content.Context;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.util.Log;
import com.example.candatasender.CarLinkData.*;
import com.example.candatasender.sender.ClientInstruction;
import com.example.candatasender.sender.DataType;
import com.example.candatasender.toserver.DataCommunications;
import com.example.useful.ShortAlertDialog;

public class CarLinkDataSend extends AsyncTask<String, String,  Boolean> {
	private Context context;
	private ProgressDialog progressDialog = null;
	private String tableName = null;
	private Date   startup;
	final int SEND_SIZE = 200;

	CarLinkDataSend(Context context) {
		this.context = context;
	}

	@Override
	protected void onPreExecute() {
		Log.d("MethodCall", "CarLinkDataSend.onPreExecute");

		if (context == null) return;
		progressDialog = new ProgressDialog(context);
		progressDialog.setTitle("データ送信中");
		progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
		progressDialog.show();
	}

	@Override
	protected Boolean doInBackground(String... args) {
		publishProgress("送信準備");

		String src = args[0];
		String dst = args[1];
		String sd  = args[2];
		tableName  = args[4];
		CanData.UsbBt usbbt;
		if (args[3].equalsIgnoreCase("usb")) {
			usbbt = CanData.UsbBt.USB;
		} else if (args[3].equalsIgnoreCase("bt")) {
			usbbt = CanData.UsbBt.BT;
		} else {
			return Boolean.FALSE;
		}
		String logDir = sd + "/" + src;
		startup = getStartup(logDir);

		ArrayList<String> videoList = new ArrayList<String>();
		videoList.add(dst);
		videoList.add(sd);

		boolean r = true;
		File log = new File(logDir);
		String[] files = log.list();
		for (String f: files) {
			Log.d("CarLinkDataSend", "send: " + f);
			if (f.startsWith("cl_can_") && f.endsWith(".csv")) {
				publishProgress("送信:" + f);
				r &= sendCan(logDir + "/" + f, usbbt);
			} else if (f.startsWith("cl_acc_") && f.endsWith(".csv")) {
				publishProgress("送信:" + f);
				r &= sendAcc(logDir + "/" + f);
			} else if (f.startsWith("cl_pose_") && f.endsWith(".csv")) {
				publishProgress("送信:" + f);
				r &= sendPose(logDir + "/" + f);
			} else if (f.startsWith("cl_loc_") && f.endsWith(".csv")) {
				publishProgress("送信:" + f);
				r &= sendLoc(logDir + "/" + f);
			} else if (f.startsWith("cl_video_") && f.endsWith(".mp4")) {
				videoList.add(src + "/" + f);
			}
		}
		r &= sendVideo(videoList);

		return Boolean.valueOf(r);
	}

	@Override
	protected void onProgressUpdate(String... args) {
		if (progressDialog != null) {
			progressDialog.setMessage(args[0]);
		}
	}

	@Override
	protected void onPostExecute(Boolean result) {
		if (progressDialog != null) {
			progressDialog.dismiss();
			progressDialog = null;
		}
		if (!result && (context != null)) {
			ShortAlertDialog.sad("Error message", "送信中にエラーが発生しました。", context);
		}
	}

	private Date getStartup(String dirname) {
		File dir = new File(dirname);
		String name = dir.getName();
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-M-d-H-m-s");
		ParsePosition pos = new ParsePosition(0);
		Date date = sdf.parse(name, pos);
		return date;
	}

	private boolean sendCan(String filename, CanData.UsbBt usbbt) {
		boolean r = true;
		String line = null;
		try {
			FileReader in = new FileReader(filename);
			BufferedReader br = new BufferedReader(in);
			ArrayList<CanData> canList = new ArrayList<CanData>();
			br.readLine(); /* 1行目空読み */
			while (true) {
				line = br.readLine();
				if (line == null) break;

				CanData can = CanData.parse(line, usbbt);
				if (can.type != CanData.CanDataType.unknown) {
					canList.add(can);
				}
				if (!br.ready() || (SEND_SIZE < canList.size())) {
					r &= sendData(CanData.name, canList);
					canList = new ArrayList<CanData>();
				}
			}
			br.close();
			in.close();
			if (canList.size() != 0) {
				r &= sendData(CanData.name, canList);
			}
		} catch (NumberFormatException e) {
			Log.e("CarLinkDataSend", e.toString());
			Log.e("CarLinkDataSend", line);
			r = false;
		} catch (FileNotFoundException e) {
			Log.e("CarLinkDataSend", e.toString());
			r = false;
		} catch (IOException e) {
			Log.e("CarLinkDataSend", e.toString());
			r = false;
		}
		return r;
	}

	private boolean sendAcc(String filename) {
		String line = null;
		boolean r = true;
		try {
			FileReader in = new FileReader(filename);
			BufferedReader br = new BufferedReader(in);
			ArrayList<AccData> accList = new ArrayList<AccData>();
			br.readLine(); /* 1行目空読み */
			while (true) {
				line = br.readLine();
				if (line == null) break;

				AccData acc = AccData.parse(line);
				accList.add(acc);
				if (!br.ready() || (SEND_SIZE < accList.size())) {
					r &= sendData(AccData.name, accList);
					accList = new ArrayList<AccData>();
				}
			}
			br.close();
			in.close();
			if (0 != accList.size()) {
				r &= sendData(AccData.name, accList);
			}
		} catch (NumberFormatException e) {
			Log.e("CarLinkDataSend", e.toString());
			Log.e("CarLinkDataSend", line);
			r = false;
		} catch (FileNotFoundException e) {
			Log.e("CarLinkDataSend", e.toString());
			r = false;
		} catch (IOException e) {
			Log.e("CarLinkDataSend", e.toString());
			r = false;
		}
		return r;
	}

	private boolean sendPose(String filename) {
		String line = null;
		boolean r = true;
		try {
			FileReader in = new FileReader(filename);
			BufferedReader br = new BufferedReader(in);
			ArrayList<PoseData> poseList = new ArrayList<PoseData>();
			br.readLine(); /* 1行目空読み */
			while (true) {
				line = br.readLine();
				if (line == null) break;

				PoseData pose = PoseData.parse(line);
				poseList.add(pose);
				if (!br.ready() || (SEND_SIZE < poseList.size())) {
					r &= sendData(PoseData.name, poseList);
					poseList = new ArrayList<PoseData>();
				}
			}
			br.close();
			in.close();
			if (poseList.size() != 0) {
				r &= sendData(PoseData.name, poseList);
			}
		} catch (NumberFormatException e) {
			Log.e("CarLinkDataSend", e.toString());
			Log.e("CarLinkDataSend", line);
			r = false;
		} catch (FileNotFoundException e) {
			Log.e("CarLinkDataSend", e.toString());
			r = false;
		} catch (IOException e) {
			Log.e("CarLinkDataSend", e.toString());
			r = false;
		}
		return r;
	}

	private boolean sendLoc(String filename) {
		String line = null;
		boolean r = true;
		try {
			FileReader in = new FileReader(filename);
			BufferedReader br = new BufferedReader(in);
			ArrayList<LocData> locList = new ArrayList<LocData>();
			br.readLine(); /* 1行目空読み */
			while (true) {
				line = br.readLine();
				if (line == null) break;

				LocData loc = LocData.parse(line);
				locList.add(loc);
				if (!br.ready() || (SEND_SIZE < locList.size())) {
					r &= sendData(LocData.name, locList);
					locList = new ArrayList<LocData>();
				}
			}
			br.close();
			in.close();
			if (locList.size() != 0) {
				r &= sendData(LocData.name, locList);
			}
		} catch (NumberFormatException e) {
			Log.e("CarLinkDataSend", e.toString());
			Log.e("CarLinkDataSend", line);
			r = false;
		} catch (FileNotFoundException e) {
			Log.e("CarLinkDataSend", e.toString());
			r = false;
		} catch (IOException e) {
			Log.e("CarLinkDataSend", e.toString());
			r = false;
		}
		return r;
	}

	private boolean sendVideo(ArrayList<String> videoList) {
		File videoFile = new File(videoList.get(2));
		String videoSplit = "${HOME}/bin/nohup-video_split.sh " +
				"\"" + videoList.get(0) + "/" + videoList.get(2) + "\" " +
				tableName + " " +
				getBaseTimestamp(videoFile.getName()) + " " +
				dateToSqlTimestamp(startup) + " " +
				getTerminal() + " " +
				videoFile.getParent();
		RawDataScp rds = new RawDataScp(context, progressDialog, null, videoSplit);
		progressDialog = null;
		rds.execute(videoList.toArray(new String[videoList.size()]));

		return true;
	}

	private String getBaseTimestamp(String filename) {
		int start = filename.indexOf("(") + 1;
		int end   = filename.indexOf(")", start);
		if (start <= 0) {
			start = filename.indexOf("_tstamp_") + 8;
			end = filename.indexOf(".mp4", start);
		}
		Log.d("CarLinkDataSend", "getBaseTimestamp filename=" + filename + ", start=" + start + ", end=" + end);
		// TODO: range check!
		return filename.substring(start, end);
	}

	private String dateToSqlTimestamp(Date date) {
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		String str = sdf.format(date);
		return "\"" + str + "\"";
	}

	private boolean sendData(String name, Object obj) {
		Map<String, Object> data = new HashMap<String, Object>();
		data.put("INST_NUM",   ClientInstruction.INST_INSERT_CL_DATA.getNum());
		data.put("TABLE_NAME", tableName);
		data.put("STARTUP",    startup);
		data.put("DATA_NAME",  name);
		data.put("DATA_OBJ",   obj);
		data.put("TERMINAL",   getTerminal());

		Map<String, Object> send = new HashMap<String, Object>();
		send.put("TYPE", DataType.DT_INST.getType());
		send.put("DATA", data);

		Map<String, Object> response = new HashMap<String, Object>();
		DataCommunications.getInstance().addSendDataNoWait(send, response);

		return true; /* TODO  */
	}

	private String getTerminal() {
		WifiManager wifiManager = (WifiManager)context.getSystemService(Context.WIFI_SERVICE);
		WifiInfo wifiInfo = wifiManager.getConnectionInfo();
		return wifiInfo.getMacAddress();
	}
}

redpajama_set_name: RedPajamaGithub


text:
package spaceinvaders.utility;

/**
 * Chain of Responsibility.
 *
 * <p>A pattern for organizing the execution of processing flows.
 */
public interface Chain<T> {
  /** Either handles the task or passes it to the next in chain. */
  public void handle(T task);

  /**
   * @param next next in chain.
   */
  public void setNext(Chain<T> next);
}


text:
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Drawing;
using System.Threading;
using Microsoft.CodeAnalysis.Host;
using Microsoft.CodeAnalysis.Navigation;
using Microsoft.CodeAnalysis.Shared.Extensions;
using Microsoft.VisualStudio.Language.NavigateTo.Interfaces;
using Roslyn.Utilities;

namespace Microsoft.CodeAnalysis.Editor.Implementation.NavigateTo
{
    internal partial class NavigateToItemProvider
    {
        private class NavigateToItemDisplay : INavigateToItemDisplay2
        {
            private readonly INavigateToSearchResult _searchResult;
            private readonly NavigateToIconFactory _iconFactory;

            private Icon _glyph;
            private ReadOnlyCollection<DescriptionItem> _descriptionItems;

            public NavigateToItemDisplay(INavigateToSearchResult searchResult, NavigateToIconFactory iconFactory)
            {
                _searchResult = searchResult;
                _iconFactory = iconFactory;
            }

            public string AdditionalInformation
            {
                get
                {
                    return _searchResult.AdditionalInformation;
                }
            }

            public string Description
            {
                get
                {
                    return null;
                }
            }

            public ReadOnlyCollection<DescriptionItem> DescriptionItems
            {
                get
                {
                    if (_descriptionItems == null)
                    {
                        _descriptionItems = CreateDescriptionItems();
                    }

                    return _descriptionItems;
                }
            }

            private ReadOnlyCollection<DescriptionItem> CreateDescriptionItems()
            {
                var document = _searchResult.NavigableItem.Document;
                var sourceText = document.GetTextAsync(CancellationToken.None).WaitAndGetResult(CancellationToken.None);

                var items = new List<DescriptionItem>
                    {
                        new DescriptionItem(
                            new ReadOnlyCollection<DescriptionRun>(
                                new[] { new DescriptionRun("Project:", bold: true) }),
                            new ReadOnlyCollection<DescriptionRun>(
                                new[] { new DescriptionRun(document.Project.Name) })),
                        new DescriptionItem(
                            new ReadOnlyCollection<DescriptionRun>(
                                new[] { new DescriptionRun("File:", bold: true) }),
                            new ReadOnlyCollection<DescriptionRun>(
                                new[] { new DescriptionRun(document.FilePath ?? document.Name) })),
                        new DescriptionItem(
                            new ReadOnlyCollection<DescriptionRun>(
                                new[] { new DescriptionRun("Line:", bold: true) }),
                            new ReadOnlyCollection<DescriptionRun>(
                                new[] { new DescriptionRun((sourceText.Lines.IndexOf(_searchResult.NavigableItem.SourceSpan.Start) + 1).ToString()) }))
                    };

                var summary = _searchResult.Summary;
                if (!string.IsNullOrWhiteSpace(summary))
                {
                    items.Add(
                        new DescriptionItem(
                            new ReadOnlyCollection<DescriptionRun>(
                                new[] { new DescriptionRun("Summary:", bold: true) }),
                            new ReadOnlyCollection<DescriptionRun>(
                                new[] { new DescriptionRun(summary) })));
                }

                return items.AsReadOnly();
            }

            public Icon Glyph
            {
                get
                {
                    if (_glyph == null)
                    {
                        _glyph = _iconFactory.GetIcon(_searchResult.NavigableItem.Glyph);
                    }

                    return _glyph;
                }
            }

            public string Name
            {
                get
                {
                    return _searchResult.NavigableItem.DisplayString;
                }
            }

            public void NavigateTo()
            {
                var document = _searchResult.NavigableItem.Document;
                var workspace = document.Project.Solution.Workspace;
                var navigationService = workspace.Services.GetService<IDocumentNavigationService>();

                // Document tabs opened by NavigateTo are carefully created as preview or regular
                // tabs by them; trying to specifically open them in a particular kind of tab here
                // has no effect.
                navigationService.TryNavigateToSpan(workspace, document.Id, _searchResult.NavigableItem.SourceSpan);
            }

            public int GetProvisionalViewingStatus()
            {
                var document = _searchResult.NavigableItem.Document;
                var workspace = document.Project.Solution.Workspace;
                var previewService = workspace.Services.GetService<INavigateToPreviewService>();

                return previewService.GetProvisionalViewingStatus(document);
            }

            public void PreviewItem()
            {
                var document = _searchResult.NavigableItem.Document;
                var workspace = document.Project.Solution.Workspace;
                var previewService = workspace.Services.GetService<INavigateToPreviewService>();

                previewService.PreviewItem(this);
            }
        }
    }
}


text:
@interface GridView ()

@property (nonatomic, strong) AlphaView *alphaView;

@end

@implementation GridView

- (void)buildView {

    CGFloat gridLength      = (self.gridLength <= 0 ? 10.f : self.gridLength);

    // 水平线条的个数
    int horizontalLineCount = 5;
    for (int i = 0; i < horizontalLineCount; i++) {

        CGRect rect          = CGRectMake(0, gridLength * i, gridLength * horizontalLineCount, 0.5);
        UIView *line         = [[UIView alloc] initWithFrame:rect];
        line.backgroundColor = COLOR_CIRCLE_;

        if (i == 0) {

            line.alpha = 0.f;

        } else if (i == horizontalLineCount - 1) {

            line.alpha = 0.f;
        }

        [self addSubview:line];
    }

    // 垂直线的个数
    int verticalLineCount = 6;
    for (int i = 0; i < verticalLineCount; i++) {

        CGRect rect          = CGRectMake(gridLength * i, 0, 0.5, gridLength * (verticalLineCount - 2));
        UIView *line         = [[UIView alloc] initWithFrame:rect];
        line.backgroundColor = COLOR_CIRCLE_;

        if (i == 0) {

            line.alpha = 0.f;

        } else if (i == verticalLineCount - 1) {

            line.alpha = 0.f;
        }

        [self addSubview:line];
    }

    self.height     = horizontalLineCount * gridLength;
    self.width      = verticalLineCount   * gridLength;
    self.viewOrigin = self.origin;

    self.alphaView = [[AlphaView alloc] initWithFrame:self.bounds];
    [self.alphaView alphaType];
    self.alphaView.x = -self.width;
    self.maskView = self.alphaView;
}

- (void)showWithDuration:(CGFloat)duration {

    [UIView animateWithDuration:duration animations:^{

        self.alphaView.x = -5;
        self.alpha = 1.f;

    } completion:^(BOOL finished) {

    }];
}

- (void)hideWithDuration:(CGFloat)duration {

    [UIView animateWithDuration:duration animations:^{

        self.alphaView.x = self.width;
        self.alpha       = 0.f;

    } completion:^(BOOL finished) {

        self.alphaView.x = -self.width;
    }];
}

@end


text:
<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision: 331664 $ -->
<refentry xml:id="function.imap-mail" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
 <refnamediv>
  <refname>imap_mail</refname>
  <refpurpose>Send an email message</refpurpose>
 </refnamediv>
 <refsect1 role="description">
  &reftitle.description;
  <methodsynopsis>
   <type>bool</type><methodname>imap_mail</methodname>
   <methodparam><type>string</type><parameter>to</parameter></methodparam>
   <methodparam><type>string</type><parameter>subject</parameter></methodparam>
   <methodparam><type>string</type><parameter>message</parameter></methodparam>
   <methodparam choice="opt"><type>string</type><parameter>additional_headers</parameter><initializer>&null;</initializer></methodparam>
   <methodparam choice="opt"><type>string</type><parameter>cc</parameter><initializer>&null;</initializer></methodparam>
   <methodparam choice="opt"><type>string</type><parameter>bcc</parameter><initializer>&null;</initializer></methodparam>
   <methodparam choice="opt"><type>string</type><parameter>rpath</parameter><initializer>&null;</initializer></methodparam>
  </methodsynopsis>
  <para>
   This function allows sending of emails with correct handling of
   Cc and Bcc receivers.
  </para>
  <para>
   The parameters <parameter>to</parameter>, <parameter>cc</parameter>
   and <parameter>bcc</parameter> are all strings and are all parsed
   as <link xlink:href="&url.rfc;822">RFC822</link> address lists.
  </para>
 </refsect1>
 <refsect1 role="parameters">
  &reftitle.parameters;
  <para>
   <variablelist>
    <varlistentry>
     <term><parameter>to</parameter></term>
     <listitem>
      <para>
       The receiver
      </para>
     </listitem>
    </varlistentry>
    <varlistentry>
     <term><parameter>subject</parameter></term>
     <listitem>
      <para>
       The mail subject
      </para>
     </listitem>
    </varlistentry>
    <varlistentry>
     <term><parameter>message</parameter></term>
     <listitem>
      <para>
       The mail body, see <function>imap_mail_compose</function>
      </para>
     </listitem>
    </varlistentry>
    <varlistentry>
     <term><parameter>additional_headers</parameter></term>
     <listitem>
      <para>
       As string with additional headers to be set on the mail
      </para>
     </listitem>
    </varlistentry>
    <varlistentry>
     <term><parameter>cc</parameter></term>
     <listitem>
      <para>
      </para>
     </listitem>
    </varlistentry>
    <varlistentry>
     <term><parameter>bcc</parameter></term>
     <listitem>
      <para>
       The receivers specified in <parameter>bcc</parameter> will get the
       mail, but are excluded from the headers.
      </para>
     </listitem>
    </varlistentry>
    <varlistentry>
     <term><parameter>rpath</parameter></term>
     <listitem>
      <para>
       Use this parameter to specify return path upon mail delivery failure.
       This is useful when using PHP as a mail client for multiple users.
      </para>
     </listitem>
    </varlistentry>
   </variablelist>
  </para>
 </refsect1>
 <refsect1 role="returnvalues">
  &reftitle.returnvalues;
  <para>
   &return.success;
  </para>
 </refsect1>
 <refsect1 role="seealso">
  &reftitle.seealso;
  <para>
   <simplelist>
    <member><function>mail</function></member>
    <member><function>imap_mail_compose</function></member>
   </simplelist>
  </para>
 </refsect1>
</refentry>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->


text:
// ==========================================================================
//                 SeqAn - The Library for Sequence Analysis
// ==========================================================================
// Copyright (c) 2006-2013, Knut Reinert, FU Berlin
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above copyright
//       notice, this list of conditions and the following disclaimer in the
//       documentation and/or other materials provided with the distribution.
//     * Neither the name of Knut Reinert or the FU Berlin nor the names of
//       its contributors may be used to endorse or promote products derived
//       from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL KNUT REINERT OR THE FU BERLIN BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
// DAMAGE.
//
// ==========================================================================
// Author: David Weese <david.weese@fu-berlin.de>
// ==========================================================================
// Bit-packed tuple specialization.
// ==========================================================================

#ifndef SEQAN_CORE_INCLUDE_SEQAN_BASIC_TUPLE_BIT_PACKED_H_
#define SEQAN_CORE_INCLUDE_SEQAN_BASIC_TUPLE_BIT_PACKED_H_

namespace seqan {

// ============================================================================
// Forwards
// ============================================================================

// ============================================================================
// Tags, Classes, Enums
// ============================================================================

/*!
 * @class BitPackedTuple
 * @extends Tuple
 * @headerfile <seqan/basic.h>
 * @brief A fixed-size tuple of values.  Memory is saved by packing bits.
 *
 * @signature template <typename TValue, unsigned SIZE>
 *            class Tuple<TValue, SIZE, BitPacked<> >;
 *
 * @tparam TValue The value type.
 * @tparam SIZE   The length of the tuple.
 *
 * The characters are stored as bit sequence in an ordinal type (char, ..., __int64).
 *
 * @section Remarks
 *
 * Only useful for small alphabets as small tuple sizes (|Sigma|^size <= 2^64 as for Dna or AminoAcid m-grams).
 */

/**
.Spec.Bit Packed Tuple:
..cat:Aggregates
..general:Class.Tuple
..summary:A plain fixed-length string. Saves memory by packing bits.
..signature:Tuple<T, SIZE, BitPacked<> >
..param.T:The value type, that is the type of characters stored in the tuple.
..param.SIZE:The size/length of the tuple.
...remarks:In contrast to @Class.String@ the length of Tuple is fixed.
..notes:The characters are stored as a bit sequence in an ordinal type (char, ..., __int64).
..remarks:Only useful for small alphabets and small tuple sizes (|Sigma|^size <= 2^64) as for @Spec.Dna@ or @Spec.AminoAcid@ m-grams)
..see:Spec.Sampler
..include:seqan/basic.h
 */

template <unsigned char SIZE>
struct BitVector_
{
    typedef typename BitVector_<SIZE + 1>::Type Type;
};

template <> struct BitVector_<8> { typedef unsigned char Type; };
template <> struct BitVector_<16> { typedef unsigned short Type; };
template <> struct BitVector_<32> { typedef unsigned int Type; };
template <> struct BitVector_<64> { typedef __uint64 Type; };
template <> struct BitVector_<255>;

// TODO(holtgrew): There is a lot of stuff defined within the class itself. A lot of it could be moved into global functions.

// bit-packed storage (space efficient)
#ifdef PLATFORM_WINDOWS
    #pragma pack(push,1)
#endif
template <typename TValue, unsigned SIZE>
struct Tuple<TValue, SIZE, BitPacked<> >
{
    typedef typename BitVector_<SIZE * BitsPerValue<TValue>::VALUE>::Type TBitVector;

    static const __uint64 BIT_MASK = ((1ull << (BitsPerValue<TValue>::VALUE - 1)       ) - 1ull) << 1 | 1ull;
    static const __uint64 MASK     = ((1ull << (SIZE * BitsPerValue<TValue>::VALUE - 1)) - 1ull) << 1 | 1ull;

    // -----------------------------------------------------------------------
    // Members
    // -----------------------------------------------------------------------

    TBitVector i;

    // -----------------------------------------------------------------------
    // Constructors
    // -----------------------------------------------------------------------

    // TODO(holtgrew): There is the unresolved issue whether the initialize costs critical performance. Since Tuples are PODs, it should be able to initialize Strings/arrays of them with memset().
    // TODO(weese): Use static a assertion outside of the constructor here, see SEQAN_CONCEPT_ASSERT
//    SEQAN_HOST_DEVICE Tuple() : i(0)
//    {
//        SEQAN_ASSERT_LEQ(static_cast<__uint64>(BitsPerValue<TValue>::VALUE * SIZE), static_cast<__uint64>(sizeof(TBitVector) * 8));
//    }

    // -----------------------------------------------------------------------
    // Subscription Operators;  Have to be declared in class.
    // -----------------------------------------------------------------------

    template <typename TPos>
    SEQAN_HOST_DEVICE inline const TValue
    operator[](TPos k) const
    {
        SEQAN_ASSERT_GEQ(static_cast<__int64>(k), 0);
        SEQAN_ASSERT_LT(static_cast<__int64>(k), static_cast<__int64>(SIZE));
        return (i >> (SIZE - 1 - k) * BitsPerValue<TValue>::VALUE) & BIT_MASK;
    }

    // -----------------------------------------------------------------------
    // Assignment Operators;  Have to be declared in class.
    // -----------------------------------------------------------------------

    template <unsigned size__>
    inline Tuple & operator=(Tuple<TValue, size__, BitPacked<> > const & right)
    {
        i = right.i;
        return *this;
    }

    // TODO(holtgrew): Move the following to global functions?

    template <typename TShiftSize>
    inline TBitVector operator<<=(TShiftSize shift)
    {
        return i = (i << (shift * BitsPerValue<TValue>::VALUE)) & MASK;
    }

    template <typename TShiftSize>
    inline TBitVector operator<<(TShiftSize shift) const
    {
        return (i << (shift * BitsPerValue<TValue>::VALUE)) & MASK;
    }

    template <typename TShiftSize>
    inline TBitVector operator>>=(TShiftSize shift)
    {
        return i = (i >> (shift * BitsPerValue<TValue>::VALUE));
    }

    template <typename TShiftSize>
    inline TBitVector operator>>(TShiftSize shift) const
    {
        return i >> (shift * BitsPerValue<TValue>::VALUE);
    }

    template <typename T>
    inline void operator|=(T const & t)
    {
        i |= ordValue(t);
    }

    inline TBitVector* operator&()
    {
        return &i;
    }

    inline const TBitVector* operator&() const
    {
        return &i;
    }

    // This to be inline because elements (like this tuple) of packed structs
    // can't be arguments.
    template <typename TPos, typename TValue2>
    inline TValue2
    assignValue(TPos k, TValue2 const source)
    {
        SEQAN_ASSERT_GEQ(static_cast<__int64>(k), 0);
        SEQAN_ASSERT_LT(static_cast<__int64>(k), static_cast<__int64>(SIZE));

        register unsigned shift = ((SIZE - 1 - k) * BitsPerValue<TValue>::VALUE);
        i = (i & ~(BIT_MASK << shift)) | (TBitVector)ordValue(source) << shift;
        return source;
    }
}
#ifndef PLATFORM_WINDOWS
    __attribute__((packed))
#endif
    ;
#ifdef PLATFORM_WINDOWS
    #pragma pack(pop)
#endif

// ============================================================================
// Metafunctions
// ============================================================================

// ============================================================================
// Functions
// ============================================================================

// -----------------------------------------------------------------------
// Function getValue()
// -----------------------------------------------------------------------

template <typename TValue, unsigned SIZE, typename TPos>
inline TValue
getValue(Tuple<TValue, SIZE, BitPacked<> > const & me,
         TPos k)
{
    SEQAN_ASSERT_GEQ(static_cast<__int64>(k), 0);
    SEQAN_ASSERT_LT(static_cast<__int64>(k), static_cast<__int64>(SIZE));

    return (me.i >> (SIZE - 1 - k) * BitsPerValue<TValue>::VALUE) & me.BIT_MASK;
}

/*
template <typename TValue, unsigned SIZE, typename TPos>
TValue
getValue(Tuple<TValue, SIZE, BitPacked<> > & me,
         TPos k)
{
    return getValue(const_cast<Tuple<TValue, SIZE, BitPacked<> > const &>(me), k);
}
*/
// -----------------------------------------------------------------------
// Function assignValue()
// -----------------------------------------------------------------------

template <typename TValue, unsigned SIZE, typename TValue2, typename TPos>
inline TValue2
assignValue(Tuple<TValue, SIZE, BitPacked<> > & me,
            TPos k,
            TValue2 const source)
{
    typedef typename Tuple<TValue, SIZE, BitPacked<> >::TBitVector TBitVector;

    SEQAN_ASSERT_GEQ(static_cast<__int64>(k), 0);
    SEQAN_ASSERT_LT(static_cast<__int64>(k), static_cast<__int64>(SIZE));

    register unsigned shift = ((SIZE - 1 - k) * BitsPerValue<TValue>::VALUE);
    me.i = (me.i & ~(me.BIT_MASK << shift)) | (TBitVector)ordValue(source) << shift;
    return source;
}

// -----------------------------------------------------------------------
// Function setValue()
// -----------------------------------------------------------------------

template <typename TValue, unsigned SIZE, typename TValue2, typename TPos>
inline TValue2
setValue(Tuple<TValue, SIZE, BitPacked<> > & me,
         TPos k,
         TValue2 const source)
{
    return assignValue(me, k, source);
}

// -----------------------------------------------------------------------
// Function moveValue()
// -----------------------------------------------------------------------

template <typename TValue, unsigned SIZE, typename TValue2, typename TPos>
inline TValue2
moveValue(Tuple<TValue, SIZE, BitPacked<> > & me,
          TPos k,
          TValue2 const source)
{
    return assignValue(me, k, source);
}

// ----------------------------------------------------------------------------
// Function move(), set(), assign()
// ----------------------------------------------------------------------------

template <typename TValue, unsigned SIZE>
inline void
move(Tuple<TValue, SIZE, BitPacked<> > & t1, Tuple<TValue, SIZE, BitPacked<> > & t2)
{
    t1.i = t2.i;
}

template <typename TValue, unsigned SIZE>
inline void
set(Tuple<TValue, SIZE, BitPacked<> > & t1, Tuple<TValue, SIZE, BitPacked<> > const & t2)
{
    t1.i = t2.i;
}

template <typename TValue, unsigned SIZE>
inline void
assign(Tuple<TValue, SIZE, BitPacked<> > & t1, Tuple<TValue, SIZE, BitPacked<> > const & t2)
{
    t1.i = t2.i;
}

// -----------------------------------------------------------------------
// Function shiftLeft()
// -----------------------------------------------------------------------

// Optimized version for packed tuple using just one word.
template <typename TValue, unsigned SIZE>
inline void shiftLeft(Tuple<TValue, SIZE, BitPacked<> > & me)
{
    me <<= 1;
}

// -----------------------------------------------------------------------
// Function shiftRight()
// -----------------------------------------------------------------------

template <typename TValue, unsigned SIZE>
inline void shiftRight(Tuple<TValue, SIZE, BitPacked<> > & me)
{
    me >>= 1;
}

// -----------------------------------------------------------------------
// Function clear()
// -----------------------------------------------------------------------

template <typename TValue, unsigned SIZE>
inline void clear(Tuple<TValue, SIZE, BitPacked<> > & me)
{
    me.i = 0;
}

// -----------------------------------------------------------------------
// Function operator<()
// -----------------------------------------------------------------------

// Optimized version for packed tuple using just one word.
template <typename TValue, unsigned SIZE>
inline bool operator<(Tuple<TValue, SIZE, BitPacked<> > const & left,
                      Tuple<TValue, SIZE, BitPacked<> > const & right)
{
    return left.i < right.i;
}

template <typename TValue, unsigned SIZE>
inline bool operator<(Tuple<TValue, SIZE, BitPacked<> > & left,
                      Tuple<TValue, SIZE, BitPacked<> > & right)
{
    return left.i < right.i;
}

// -----------------------------------------------------------------------
// Function operator>()
// -----------------------------------------------------------------------

// Optimized version for packed tuple using just one word.
template <typename TValue, unsigned SIZE>
inline bool operator>(Tuple<TValue, SIZE, BitPacked<> > const & left,
                      Tuple<TValue, SIZE, BitPacked<> > const & right)
{
    return left.i > right.i;
}

template <typename TValue, unsigned SIZE>
inline bool operator>(Tuple<TValue, SIZE, BitPacked<> > & left,
                      Tuple<TValue, SIZE, BitPacked<> > & right)
{
    return left.i > right.i;
}

// -----------------------------------------------------------------------
// Function operator<=()
// -----------------------------------------------------------------------

// Optimized version for packed tuple using just one word.
template <typename TValue, unsigned SIZE>
inline bool operator<=(Tuple<TValue, SIZE, BitPacked<> > const & left,
                       Tuple<TValue, SIZE, BitPacked<> > const & right)
{
    return !operator>(left, right);
}

template <typename TValue, unsigned SIZE>
inline bool operator<=(Tuple<TValue, SIZE, BitPacked<> > & left,
                       Tuple<TValue, SIZE, BitPacked<> > & right)
{
    return !operator>(left, right);
}

// -----------------------------------------------------------------------
// Function operator>()
// -----------------------------------------------------------------------

// Optimized version for packed tuple using just one word.
template <typename TValue, unsigned SIZE>
inline bool operator>=(Tuple<TValue, SIZE, BitPacked<> > const & left,
                       Tuple<TValue, SIZE, BitPacked<> > const & right)
{
    return !operator<(left, right);
}

template <typename TValue, unsigned SIZE>
inline bool operator>=(Tuple<TValue, SIZE, BitPacked<> > & left,
                       Tuple<TValue, SIZE, BitPacked<> > & right)
{
    return !operator<(left, right);
}

// -----------------------------------------------------------------------
// Function operator==()
// -----------------------------------------------------------------------

// Optimized version for packed tuple using just one word.
template <typename TValue, unsigned SIZE>
inline bool operator==(Tuple<TValue, SIZE, BitPacked<> > const & left,
                       Tuple<TValue, SIZE, BitPacked<> > const & right)
{
    return left.i == right.i;
}

template <typename TValue, unsigned SIZE>
inline bool operator==(Tuple<TValue, SIZE, BitPacked<> > & left,
                       Tuple<TValue, SIZE, BitPacked<> > & right)
{
    return left.i == right.i;
}

// -----------------------------------------------------------------------
// Function operator!=()
// -----------------------------------------------------------------------

// Optimized version for packed tuple using just one word.
template <typename TValue, unsigned SIZE>
inline bool operator!=(Tuple<TValue, SIZE, BitPacked<> > const & left,
                       Tuple<TValue, SIZE, BitPacked<> > const & right)
{
    return !operator==(left, right);
}

template <typename TValue, unsigned SIZE>
inline bool operator!=(Tuple<TValue, SIZE, BitPacked<> > & left,
                       Tuple<TValue, SIZE, BitPacked<> > & right)
{
    return !operator==(left, right);
}

}  // namespace seqan

#endif  // #ifndef SEQAN_CORE_INCLUDE_SEQAN_BASIC_TUPLE_BIT_PACKED_H_


text: :package: Microservices Trailpack


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <parent>
    <groupId>org.pentaho.webpackage</groupId>
    <artifactId>extenders-modules</artifactId>
    <version>8.1-SNAPSHOT</version>
  </parent>

  <artifactId>http-extender-impl</artifactId>
  <version>8.1-SNAPSHOT</version>

  <packaging>bundle</packaging>

  <dependencies>
    <dependency>
      <groupId>org.pentaho.webpackage</groupId>
      <artifactId>core-api</artifactId>
      <version>${project.version}</version>
    </dependency>

    <dependency>
      <groupId>org.osgi</groupId>
      <artifactId>org.osgi.core</artifactId>
      <version>${org.osgi.core.version}</version>
      <scope>provided</scope>
      <exclusions>
        <exclusion>
          <groupId>*</groupId>
          <artifactId>*</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>org.ops4j.pax.web</groupId>
      <artifactId>pax-web-extender-whiteboard</artifactId>
      <version>${pax-web-extender-whiteboard.version}</version>
      <scope>provided</scope>
      <exclusions>
        <exclusion>
          <groupId>*</groupId>
          <artifactId>*</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>com.googlecode.json-simple</groupId>
      <artifactId>json-simple</artifactId>
      <version>${json-simple.version}</version>
      <exclusions>
        <exclusion>
          <groupId>*</groupId>
          <artifactId>*</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
      <version>${slf4j-api.version}</version>
      <scope>provided</scope>
      <exclusions>
        <exclusion>
          <groupId>*</groupId>
          <artifactId>*</artifactId>
        </exclusion>
      </exclusions>
    </dependency>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>${junit.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.mockito</groupId>
      <artifactId>mockito-all</artifactId>
      <version>${mockito.version}</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.felix</groupId>
        <artifactId>maven-bundle-plugin</artifactId>
        <version>${maven-bundle-plugin.version}</version>

        <extensions>true</extensions>

        <configuration>
          <instructions>
            <Bundle-Activator>org.pentaho.webpackage.extender.http.impl.osgi.Activator</Bundle-Activator>
          </instructions>
        </configuration>
      </plugin>
    </plugins>
  </build>

</project>


text:
/**
 * @author = Mikhail Dumchev;
 * Функция отвечает за проверку данных, которые ввёл пользователь в текстовые поля формы "Form";
 * @param {object} Form Форма или часть формы, для полей которой будет применятся функция валидации введённых данных;
 * @param {number} type Страница ("0" - проверка на странице "Настройки", "1" - проверка на странице "Добавление скидки");
*/
function validation(Form) {
	"use strict";
	//Счётчик, который используется в циклах для поиска элементов, которые имеют атрибут "data-validation";
	var counter = 0;
	//Счётчик, который используется в циклах для поиска элементов;
	var additoryCounter = 0;
	//Индикатор отсутствия ошибок;
	var indicator = true;
	for (counter = 0; counter < Form.getElementsByTagName("div").length; counter++)
		if (Form.getElementsByTagName("div")[counter].hasAttribute("data-validation-type")) {
			var Container = Form.getElementsByTagName("div")[counter];
			var Element = new Object();
			switch (parseInt(Container.getAttribute("data-validation-type"))) {
				case 1:
					for (additoryCounter = 0; additoryCounter < Container.getElementsByTagName("textarea").length; additoryCounter++) {
						Element = Container.getElementsByTagName("textarea")[additoryCounter];
						if (!errorShowingFirstType(Element)) indicator = false;
					}
					for (additoryCounter = 0; additoryCounter < Container.getElementsByTagName("input").length; additoryCounter++) {
						Element = Container.getElementsByTagName("input")[additoryCounter];
						if (Element.type === "text")
							if (!errorShowingFirstType(Element)) indicator = false;
					}
					break;
				case 2:
					if (!document.getElementById("recent_acquisitions").checked) {
						for (additoryCounter = 0; additoryCounter < Container.getElementsByTagName("input").length; additoryCounter++) {
							Element = Container.getElementsByTagName("input")[additoryCounter];
							if (Element.type !== "hidden" && Element.type !== "checkbox" && !Element.hasAttribute("readonly"))
								if (!errorShowingSecondType(Element)) indicator = false;
						}
					}
					break;
				case 3:
					for (additoryCounter = 0; additoryCounter < Container.getElementsByTagName("input").length; additoryCounter++) {
						Element = Container.getElementsByTagName("input")[additoryCounter];
						if (Element.type === "text")
							if (!errorShowingThirdType(Element)) indicator = false;
					}
					break;
				case 4:
					if (!errorShowingFourthType(Container)) indicator = false;
					break;
				case 5:
					if (!errorShowingFifthType(Container)) indicator = false;
					break;
				default: break;
			}
		}
	return indicator;
}

/**
 * @author = Mikhail Dumchev;
 * Функция отвечает за проверку значения, которое содержится в текстовом поле перед его отправкой на сервер. Функция применяется для проверки текстовых полей типа "input"
 * и "textarea" на страницах "Настройки" и "Добавление скидки". Осуществляется проверка на заполнение поля;
 * @param {object} Element Текстовое поле, которое необходимо проверить;
*/
function errorShowingFirstType(Element) {
	"use strict";
	//Если текстовое поле не заполнено, и сообщение об этой ошибке уже выведено в этом поле;
	if (!Element.value.length && Element.className !== "error") {
		//Вывод сообщения об ошибке;
		Element.value = "Обязательное поле.";
		//Полю присваивается класс "error". Этот класс необходим как для добавления стилей, так и для логики программы;
		if (Element.className.length) Element.className = Element.className + " ";
		Element.className = "error";
		Element.addEventListener("focus", refresh, false);
		//Добавление изображения восклицательного знака;
		var Image = document.createElement("div");
		Image.className = "error";
		Element.parentNode.appendChild(Image);
		//Вертикальная составляющая положения изображения с восклицательным знаком вычисляется в зависимости от типа этого поля;
		switch (Element.nodeName.toLowerCase()) {
			case "textarea":
				Image.style.top = Element.offsetTop + parseInt(getComputedStyle(Element, "").paddingTop) / 2 + "px";
				break;
			case "input":
				Image.style.top = Element.offsetTop + (Element.clientHeight - Image.offsetHeight) / 2 + 1 + "px";
				break;
			default: break;
		}
		Image.style.left = Element.clientWidth - Image.offsetWidth - 4 + "px";
		Image.addEventListener("click", refresh, false);
	}
	if (Element.value.length && Element.className !== "error") return true;
	else return false;
}

/**
 * @author = Mikhail Dumchev;
 * Функция отвечает за проверку значения, которое содержится в текстовом поле перед его отправкой на сервер. Функция применяется для проверки текстовых полей типа "input"
 * на странице "Добавление скидки". Осуществляется проверка на заполнение поля и на правильность ввода вещественного числа в это поле;
 * @param {object} Element Текстовое поле, которое необходимо проверить;
*/
function errorShowingSecondType(Element) {
	"use strict";
	//Индикатор наличия ошибок. Он может принимать такие значения:
	//+ 0 - ошибки отсутствуют;
	//+ 1 - поле не заполнено;
	//+ 2 - поле заполнено неправильно;
	var indicator = 0;
	//Шаблон для регулярных выражений (проверка на вещественное число);
	var pattern = /^[0-9]+\.*[0-9]*$/;
	//Проверка на ошибки нужна только в том случае, если поле не имеет класса "error", то есть, если оно ещё не проверялось, или пользователь сфокусировался на нём,
	//тем самым убрав сообщение об ошибке;
	if (Element.className !== "error") {
		if (!Element.value.length)
			indicator = 1;
		else
			if (!pattern.test(Element.value))
				indicator = 2;
	}
	//Если была обнаружена ошибка;
	if (indicator) {
		//Если пользователь неправильно заполнил поле, необходимо сохранить то, что ввёл пользователь, перед тем, как вывести в это поле сообщение об ошибке;
		if (indicator === 2) Element.setAttribute("data-content", Element.value);
		//Вывод сообщения об ошибке;
		Element.value = "Введите число.";
		//Полю присваивается класс "error". Этот класс необходим как для добавления стилей, так и для логики программы;
		if (Element.className.length) Element.className = Element.className + " ";
		Element.className = "error";
		Element.addEventListener("focus", refresh, false);
		//Добавление изображения восклицательного знака;
		var Image = document.createElement("div");
		Image.className = "error";
		Element.parentNode.appendChild(Image);
		Image.style.top = Element.offsetTop + (Element.clientHeight - Image.offsetHeight) / 2 + 1 + "px";
		Image.style.left = Element.clientWidth - Image.offsetWidth + parseInt(Element.offsetLeft) + "px";
		Image.addEventListener("click", refresh, false);
	}
	if (!indicator) return true;
	else return false;
}

/**
 * @author = Mikhail Dumchev;
 * Функция отвечает за проверку значения, которое содержится в текстовом поле перед его отправкой на сервер. Функция применяется для проверки текстовых полей типа "input"
 * на странице "Настройки". Проверка осуществляется в том случае, если пользователь ввёл какую-то информацию в текстовое поле;
 * @param {object} Element Текстовое поле, которое необходимо проверить;
*/
function errorShowingThirdType(Element) {
	"use strict";
	var indicator = true;
	//Шаблон для регулярных выражений (для проверки e-mail(-а) или номера телефона);
	var pattern = /.?/;
	//Выбор шаблона для проверки значения текстового поля в зависимости от имени этого текстового поля;
	switch (Element.name) {
		case "email":
			pattern = /^((https?)\:\/\/)?([a-z0-9]{1})((\.[a-z0-9-])|([a-z0-9-]))*\.([a-z]{2,6})(\/[a-z0-9]*\/*){0,3}$/;
			break;
		default:
			pattern = /^((8|\+7)[\- ]?)?(\(?\d{3}\)?[\- ]?)?[\d\- ]{7,10}$/;
			break;
	}
	if (Element.value.length && !pattern.test(Element.value) && Element.className !== "error") {
		//Если пользователь неправильно заполнил поле, необходимо сохранить то, что ввёл пользователь, перед тем, как вывести в это поле сообщение об ошибке;
		Element.setAttribute("data-content", Element.value);
		//Вывод сообщения об ошибке;
		Element.value = "Неправильно.";
		//Полю присваивается класс "error". Этот класс необходим как для добавления стилей, так и для логики программы;
		if (Element.className.length) Element.className = Element.className + " ";
		Element.className = "error";
		Element.addEventListener("focus", refresh, false);
		//Добавление изображения восклицательного знака;
		var Image = document.createElement("div");
		Image.className = "error";
		Element.parentNode.appendChild(Image);
		Image.style.top = Element.offsetTop + (Element.clientHeight - Image.offsetHeight) / 2 + 1 + "px";
		Image.style.left = Element.clientWidth - Image.offsetWidth - 4 + "px";
		Image.addEventListener("click", refresh, false);
		indicator = false;
	}
	return indicator;
}

/**
 * @author = Mikhail Dumchev;
 * Функция отвечает за проверку значения, которое содержится в текстовом поле перед его отправкой на сервер. Функция применяется для проверки текстовых полей типа "input",
 * которые связаны с выпадающим меню на странице "Добавление скидки";
 * @param {object} Container Блок, в котором находятся текстовые поля, которые необходимо проверить;
*/
function errorShowingFourthType(Container) {
	"use strict";
	//Счётчик, который используется для поиска текстовых полей типа "hidden" в элементе "Container";
	var counter = 0;
	//Счётчик, который используется для поиска кнопки типа "submit" в форме с именем "discount_addition". Сообщение об ошибке должно выводиться около этой кнопки;
	var internalCounter = 0;
	//Цикл должен "проверить" все текстовые поля в элементе "Container" и не должен срабатывать, если сообщение уже выведено;
	while (counter < Container.getElementsByTagName("input").length && !Container.hasAttribute("error")) {
		if (Container.getElementsByTagName("input")[counter].type === "hidden") {
			var TextField = Container.getElementsByTagName("input")[counter];
			//Если поле не заполнено;
			if (!TextField.value.length) {
				//Установка атрибута-заглушки. Она свидетельствует о том, что сообщение об ошибке уже выведено;
				Container.setAttribute("error", true);
				//Создание блока с сообщением об ошибке и элемента с изображением восклицательного знака;
				var Message = document.createElement("p");
				Message.innerHTML = "Не указан тип товара.";
				Message.className = "error";
				var Image = document.createElement("div");
				Image.className = "error";
				Image.setAttribute("cursor", "default");
				//Поиск кнопки типа "submit" в форме с названием "discount_addition". Сообщение об ошибке должно выводиться около этой кнопки;
				for (internalCounter = 0; internalCounter < document.getElementsByName("discount_addition")[0].getElementsByTagName("input").length; internalCounter++)
					if (document.getElementsByName("discount_addition")[0].getElementsByTagName("input")[internalCounter].type === "submit") {
						var Element = document.getElementsByName("discount_addition")[0].getElementsByTagName("input")[internalCounter];
						Element.parentNode.appendChild(Message);
						Element.parentNode.appendChild(Image);
						Message.style.top = (Element.parentNode.clientHeight - Message.offsetHeight) / 2 + "px";
						Message.style.left = Element.offsetLeft + Element.clientWidth + Image.offsetWidth + 9 + "px";
						Image.style.top = (Element.parentNode.clientHeight - Image.offsetHeight) / 2 + "px";
						Image.style.left = Element.offsetLeft + Element.clientWidth + 7 + "px";
						Container.addEventListener("click", popDownMenuRefresh, false);
					}
			}
		}
		counter = counter + 1;
	}
	if (Container.hasAttribute("error")) return false;
	else return true;
}

function errorShowingFifthType(Container) {
	"use strict";
	//Счётчик, который используется для поиска блоков, которые отвечают за добавление новых дней и часов работы, в элементе "Container" (блок "Часы работы");
	var counter = 0;
	//Счётчик, который используется для поиска текстовых полей во втором элементе "div" первого уровня вложенности в блоке "Container";
	var internalCounter = 0;
	//Шаблон для регулярного выражения (проверка на ввод численных данных в текстовое поле);
	var pattern = /\s*error\s*/;
	//Индикатор отсутствия ошибок;
	var indicator = true;
	//Массив, который содержит индикаторы, которые в свою очередь указывают на заполнение текстовых полей;
	var indicatorsArray = [];
	//Индикатор, который указывает на заполнение хотя бы одного текстового поля в каждой четвёрке текстовых полей;
	var additoryIndicator = false;
	//Счётчик, который используется для вывода ошибок в текстовых полях;
	var additoryCounter = 0;
	//Индикатор, который указывает, отмечен ли хотя бы один "checkbox" в первом блоке первого уровня вложенности в элементе "Container";
	var checkboxIndicator = false;
	//Элемент "div", в котором находятся текстовые поля, которые необходимо проверить;
	var Element = new Object();
	//Текстовое поле;
	var TextField = new Object();
	//Форма, в которой находится блок "Container";
	var Form = new Object();
	//Кнопка типа "submit" в форме "Form". Эта кнопка находится на первом уровне вложенности;
	var Button = new Object();
	//Блок, на заднем фоне которого находится изображение восклицательного знака;
	var Image = new Object();
	//Блок "p" с сообщением об ошибке, которое выводится около кнопки "Button";
	var Message = new Object();
	//Поиск всех блоков для добавления новых дней и часов работы в элементе "Container";
	for (counter = 0; counter < Container.children.length; counter++) {
		if (Container.children[counter].nodeName === "DIV") {
			//По логике вёрстки каждый блок для добавления новых дней и часов работы состоит из двух элементов "div" первого уровня вложенности (в первом "div" указываются дни
			//работы, во втором - часы);
			Element = Container.children[counter].children[1];
			//Поиск текстовых полей во втором элементе "div", который находится в блоке "Container" на первом уровне вложенности;
			for (internalCounter = 0; internalCounter < Element.getElementsByTagName("input").length; internalCounter++) {
				//Заполнение массива индикаторов, которые указывают на заполнение текстовых полей;
				if (!Element.getElementsByTagName("input")[internalCounter].value.length) {
					indicatorsArray[internalCounter] = "-";
				} else {
					indicatorsArray[internalCounter] = "+";
					//Не нужно лишний раз менять значение переменной;
					if (!additoryIndicator) additoryIndicator = true;
				}
				//Каждое поле ("Время работы" и "Время обеда") состоит из четырёх текстовых полей, поэтому осуществляется проверка секции из четырйх текстовых полей. Проверка
				//должна осуществляться только в том случае, если было заполнено хотя бы одно текстовое поле, на что указывает переменная-индикатор "additoryIndicator". Для
				//определения текущей секции из четырёх полей к переменной "internalCounter" необходимо добавлять единицу потому, что нумерация DOM-элементов начинается с
				//нуля. Последние поля в первой и второй секции будут иметь номера 3 и 7 соответственно, а условием определения новой секции служит деление без остатка на 4.
				//На нумерацию DOM-элементов такое сложение никак не влияет;
				if ((internalCounter + 1) % 4 === 0 && additoryIndicator) {
					for (additoryCounter = internalCounter - 3; additoryCounter <= internalCounter; additoryCounter++)
						if (indicatorsArray[additoryCounter] === "-") {
							//Непосредственный вывод сообщения об ошибке. Должен осуществляться только в том случае, если сообщение об ошибке ещё не выведено, о чём свидетельствует
							//отсутствие у текстового поля класса "error";
							if (!pattern.test(Element.getElementsByTagName("input")[additoryCounter].className)) errorReporting(Element.getElementsByTagName("input")[additoryCounter]);
							//Не нужно лишний раз менять значение переменной;
							if (indicator) indicator = false;
						}
					//Переменная "additoryIndicator" должна обнуляться перед проверкой следующей секции из четырёх полей;
					additoryIndicator = false;
				}
			}
			//Если на первом этапе (проверка на заполнение всех текстовых полей в секции из четырёх полей) не было найдено ошибок, то есть все поля были заполнены или не заполнены.
			//На данном этапе текстовые поля проверяются на корректность заполнения;
			if (indicator) {
				pattern = /^[0-9]+$/;
				for (internalCounter = 0; internalCounter < Element.getElementsByTagName("input").length; internalCounter++)
					//Если пользователь ввёл какую-то информацию в текстовое поле, и эта информация не имеет численный тип данных, или в чётном по порядку следования текстовом поле
					//находится число, которое больше, чем 23, (во все чётные поля вводятся часы работы или обеда) или в нечётном по порядку следования текстовом поле находится число,
					//которое больше 60 (в нечётных по порядку следования текстовых полях вводятся минуты работы или обеда);
					if (Element.getElementsByTagName("input")[internalCounter].value && !pattern.test(Element.getElementsByTagName("input")[internalCounter].value) ||
						!(internalCounter % 2) && Element.getElementsByTagName("input")[internalCounter].value > 23
						|| (internalCounter % 2) && Element.getElementsByTagName("input")[internalCounter].value > 59) {
							errorReporting(Element.getElementsByTagName("input")[internalCounter]);
							//Не нужно лишний раз менять значение переменной;
							if (indicator) indicator = false;
					}
			}
			//Если заполнено хотя бы одно поле в одной из двух секций из четырёх текстовых полей, необходимо проверить, отмечен ли хотя бы один "checkbox". Переменная-индикатор
			//не подходит для этой проверки, поскольку она проверяет заполнение каждой секции из четырёх полей и обновляется перед проверкой второй секции, которая может быть
			//не заполнена;
			if (indicatorsArray.indexOf("+") !== -1) {
				internalCounter = 0;
				//По логике вёрстки каждый блок для добавления новых дней и часов работы состоит из двух элементов "div" первого уровня вложенности (в первом "div" указываются дни
				//работы, во втором - часы);
				Element = Container.children[counter].children[0];
				//Проверка на то, отмечен ли хотя бы один "checkbox" в первом блоке первого уровня вложенности в элементе "Container";
				while (internalCounter < Element.getElementsByTagName("input").length && !checkboxIndicator) {
					if (Element.getElementsByTagName("input")[internalCounter].type === "checkbox" && Element.getElementsByTagName("input")[internalCounter].checked)
						checkboxIndicator = true;
					internalCounter++;
				}
				//Если ни один "checkbox" не отмечен, около кнопки "Сохранить" нужно вывести сообщение об ошибке;
				if (!checkboxIndicator && !Container.hasAttribute("error")) {
					//Не нужно лишний раз менять значение переменной;
					if (indicator) indicator = false;
					Form = Container;
					//Установка атрибута-заглушки, который препятствует многократному выводу сообщения об ошибке около кнопки типа "submit" в форме "Form";
					Container.setAttribute("error", true);
					//Поиск формы, в которой находится элемент "Container" (блок "Часы работы");
					while (Form.nodeName !== "FORM" && Form.nodeName !== "BODY") Form = Form.parentNode;
					//Поиск кнопки типа "submit" в форме "Form";
					for (internalCounter = 0; internalCounter < Form.children.length; internalCounter++)
						if (Form.children[internalCounter].nodeName === "INPUT" && Form.children[internalCounter].type === "submit")
							Button = Form.children[internalCounter];
					//Вывод сообщения об ошибке;
					Message = document.createElement("p");
					Message.className = "error";
					Message.innerHTML = "*Вы не указали дни работы.";
					Form.appendChild(Message);
					Message.style.top = (Button.offsetTop + (Button.clientHeight - Message.clientHeight) / 2 - 1) + "px";
					Message.style.left = (Button.clientWidth + 10) + "px";
					Container.addEventListener("click", workingDayRefresh, false);
				}
			//Если ни одно текстовое поле не заполнено;
			} else {
				internalCounter = 0;
				//По логике вёрстки каждый блок для добавления новых дней и часов работы состоит из двух элементов "div" первого уровня вложенности (в первом "div" указываются дни
				//работы, во втором - часы);
				Element = Container.children[counter].children[0];
				//Проверка на то, отмечен ли хотя бы один "checkbox" в первом блоке первого уровня вложенности в элементе "Container";
				while (internalCounter < Element.getElementsByTagName("input").length && !checkboxIndicator) {
					if (Element.getElementsByTagName("input")[internalCounter].type === "checkbox" && Element.getElementsByTagName("input")[internalCounter].checked)
						checkboxIndicator = true;
					internalCounter++;
				}
				//Если отмечен хотя бы один "checkbox", необходимо вывести сообщение об ошибке;
				if (checkboxIndicator) {
					console.log("Ошибка!");
				}
			}
		}
	}
	return indicator;
}

function errorReporting(TextField) {
	//Сохранение инфорации, которую ввёл пользователь в поле, в котором была найдена ошибка;
	TextField.setAttribute("data-content", TextField.value);
	//Сохранение атрибута "placeholder" того поля, в котором была найдена ошибка;
	TextField.setAttribute("data-placeholder", TextField.placeholder);
	//Очистка текстового поля, в котором была найдена ошибка;
	TextField.value = "";
	TextField.removeAttribute("placeholder");
	TextField.addEventListener("focus", workingHoursRefresh, false);
	//Добавление класса "error" к текстовому полю, в котором была найдена ошибка;
	if (TextField.className.length) TextField.className = TextField.className + " ";
	TextField.className = "error";
	//Добавление изображения восклицательного знака;
	Image = document.createElement("div");
	Image.className = "error";
	TextField.parentNode.appendChild(Image);
	Image.setAttribute("data-reference", TextField.getAttribute("name"));
	Image.style.top = TextField.offsetTop + (TextField.clientHeight - Image.offsetHeight) / 2 + 1 + "px";
	Image.style.left = TextField.offsetLeft + (TextField.clientWidth - Image.offsetWidth) / 2 + 1 + "px";
	Image.addEventListener("click", workingHoursRefresh, false);
}

/**
 * @author = Mikhail Dumchev;
 * Функция отвечает за удаление сообщения об ошибке, которое выводится в текстовом поле, при нажатии на это текстовое поле или на блок с изображением восклицательного
 * знака, который относится к этому текстовому полю;
 * @param {object} event Объект события, в котором содержится информация об этом событии;
*/
function refresh(event) {
	"use strict";
	//Счётчик, который используется для поиска текстового поля в том случае, если пользователь нажал на изображение восклицательного знака;
	var counter = 0;
	//Индикатор того, что текстовое поле найдено (сообщение об ошибке, которое выводится в текстовом поле, должно убираться и в том случае, если пользователь
	//нажимает на изображение восклицательного знака);
	var indicator = false;
	//Шаблон для регулярных выражений (проверка на наличие класса "error" у текстового поля);
	var pattern = /\s*error\s*/;
	//В Mozilla Firefox нет глобальной переменной "window.event";
	var event = event || window.event;
	//Объект "TextField" - текстовое поле, с которым в данный момент взаимодействует пользователь;
	var TextField = event.target;
	if (TextField.nodeName === "TEXTAREA" || TextField.nodeName === "INPUT") indicator = true;
	else {
		var Container = TextField.parentNode;
		//Поиск ведётся до тех пор, пока не будут проверены все элементы, которые находятся в родителе блока с изображением восклицательного знака, или не будет найдено
		//текстовое поле, к которому относится данное изображение;
		while (counter < Container.children.length && !indicator) {
			TextField = Container.children[counter];
			if ((TextField.nodeName === "TEXTAREA" || TextField.nodeName === "INPUT") && pattern.test(TextField.className)) indicator = true;
			counter = counter + 1;
		}
	}
	if (pattern.test(TextField.className) && indicator) {
		//В атрибуте "data-content" содержится значение, которое было введено пользователем, но не прошло проверку. При скрытии сообщения об ошибке необходимо
		//восстановить это значение;
		if (TextField.hasAttribute("data-content")) {
			TextField.value = TextField.getAttribute("data-content");
			TextField.removeAttribute("data-content");
		} else TextField.value = "";
		//Удаление класса "error";
		TextField.className = TextField.className.replace(new RegExp(pattern), "");
		if (!TextField.className.length) TextField.removeAttribute("class");
		TextField.removeEventListener("focus", refresh, false);
		//Удаление блока с изображением восклицательного знака;
		for (counter = 0; counter < TextField.parentNode.children.length; counter++)
			if (TextField.parentNode.children[counter].nodeName === "DIV" && pattern.test(TextField.parentNode.children[counter].className))
				TextField.parentNode.removeChild(TextField.parentNode.children[counter]);
		TextField.focus();
	}
}

/**
 * @author = Mikhail Dumchev;
 * Функция отвечает за удаление сообщения об ошибке, которое выводится около кнопки типа "submit" в форме с именем "discount_addition". Сообщение удаляется при нажатии
 * на выпадающее меню (элемент с классом "productType");
 * @param {object} event Объект события, в котором содержится информация об этом событии;
*/
function popDownMenuRefresh(event) {
	"use strict";
	//Счётчик, который используется для поиска кнопки типа "submit" в форме с именем "discount_addition". Сообщение об ошибке должно выводиться около этой кнопки;
	var counter = 0;
	//Счётчик, который используется для удаления элементов, которые составляют сообщение об ошибке (элементы "p" и "div");
	var internalCounter = 0;
	//В Mozilla Firefox нет глобальной переменной "window.event";
	var event = event || window.event;
	//Шаблон для регулярных выражений (проверка на наличие класса у элемента класса "productType" и "error");
	var pattern = /\s*productType\s*/;
	//Объект "Container" - элемент с классом "productType";
	var Container = event.target;
	while (!pattern.test(Container.className) && Container.nodeName !== "BODY") Container = Container.parentNode;
	//Если элемент с классом "productType" найден, необходимо удалить в нём те элементы, которые составляют сообщение об ошибке, иначе выводится сообщение об ошибке;
	if (Container) {
		//Удаление атрибута-индикатора "error" и обработчика события "click" у элемента с классом "discount_addition";
		Container.removeAttribute("error");
		Container.removeEventListener("click", popDownMenuRefresh, false);
		//Удаление элементов, которые составляют сообщение об ошибке;
		pattern = /\s*error\s*/;
		for (counter = 0; counter < document.getElementsByName("discount_addition")[0].getElementsByTagName("input").length; counter++)
			if (document.getElementsByName("discount_addition")[0].getElementsByTagName("input")[counter].type === "submit") {
				var Element = document.getElementsByName("discount_addition")[0].getElementsByTagName("input")[counter].parentNode;
				for (internalCounter = 0; internalCounter < Element.children.length; internalCounter++)
					if (pattern.test(Element.children[internalCounter].className)) {
						Element.removeChild(Element.children[internalCounter]);
						internalCounter = internalCounter - 1;
					}
			}
	} else console.log("Элемент с классом 'productType' не найден;");
}

function workingHoursRefresh(event) {
	"use strict";
	//В Mozilla Firefox нет глобальной переменной "window.event";
	var event = event || window.event;
	//Шаблон для регулярного выражения (проверка наличия класса "error");
	var pattern = /\s*error\s*/;
	//Счётчик, который используется для поиска текстового поля и блока с изображением восклицательного знака;
	var counter = 0;
	//Текстовое поле, в котором обнаружена ошибка;
	var TextField = event.target;
	//Элемент, который служит родителем для элемента (текстовое поле или блок с изображением восклицательного знака), который выбрал пользователь;
	var Container = TextField.parentNode;
	//Если пользователь нажал не на текстовое поле, а на блок с изображением восклицательного знака, происходит поиск текстового поля, к которому относится этот блок.
	//Такое отношение определяется через сравнение атрибута "data-reference" блока с изображением восклицательного знака и атрибута "name" текстового поля;
	if (TextField.nodeName !== "TEXTAREA" || TextField.nodeName !== "INPUT")
		for (counter = 0; counter < Container.children.length; counter++)
			if (Container.children[counter].nodeName === "INPUT" && Container.children[counter].hasAttribute("name")
			    && Container.children[counter].getAttribute("name") === event.target.getAttribute("data-reference"))
					TextField = Container.children[counter];
	//Восстановление атрибута "placeholder" и информации, которую пользователь ввёл в текстовое поле;
	TextField.value = TextField.getAttribute("data-content");
	TextField.placeholder = TextField.getAttribute("data-placeholder");
	TextField.removeAttribute("data-content");
	TextField.removeAttribute("data-placeholder");
	//Удаление обработчика событий;
	TextField.removeEventListener("focus", workingHoursRefresh, false);
	//Удаление класса "error";
	TextField.className = TextField.className.replace(new RegExp(pattern), "");
	if (!TextField.className.length) TextField.removeAttribute("class");
	//Поиск блока с изображением восклицательного знака, который относится к текстовому полю "TextField";
	if (event.target.nodeName !== "DIV" && pattern.test(event.target.className) && event.target.hasAttribute("data-reference"))
		Container.removeChild(event.target);
	else
		for (counter = 0; counter < Container.children.length; counter++)
			if (Container.children[counter].nodeName === "DIV" && Container.children[counter].hasAttribute("data-reference")
				&& Container.children[counter].getAttribute("data-reference") === TextField.getAttribute("name"))
					Container.removeChild(Container.children[counter]);
	TextField.focus();
}

function workingDayRefresh(event) {
	"use strict";
	//В Mozilla Firefox нет глобальной переменной "window.event";
	var event = event || window.event;
	var counter = 0;
	var pattern = /\s*workingHours\s*/;
	var Element = new Object();
	if (event.target.nodeName === "LABEL") {
		Element = event.target;
		while (Element.nodeName !== "FORM" && Element.nodeName !== "BODY") {
			Element = Element.parentNode;
			if (pattern.test(Element.className) && Element.hasAttribute("Error")) {
				Element.removeEventListener("click", workingDayRefresh, false);
				Element.removeAttribute("error");
			}
		}
		pattern = /\s*error\s*/;
		if (Element.nodeName === "FORM")
			for (counter = 0; counter < Element.children.length; counter++)
				if (Element.children[counter].nodeName === "P" && pattern.test(Element.children[counter].className))
					Element.removeChild(Element.children[counter]);
	}
}
//Вы не указали день недели.


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

namespace SFDC.gvr
{
	public class GvrExitToMenuControl : MonoBehaviour
	{
		public AudioClip sceneTransition;

		private float touchStart = 0f;
		private bool isTransitioning = false;

		private const float PRESS_DURATION = 2f;

		public void Update()
		{
			if (isTransitioning)
				return;

			if (GvrController.AppButtonDown)
				touchStart = Time.time;
			else if (GvrController.AppButtonUp)
				touchStart = 0;
			else if (touchStart != 0f)
			{
				float pressDuration = Time.time - touchStart;
				if (pressDuration >= PRESS_DURATION)
					StartCoroutine(transitionToMenu());
			}
		}

		private IEnumerator transitionToMenu()
		{
			isTransitioning = true;
			// Start to load next scene
			AsyncOperation ao = SceneManager.LoadSceneAsync("Menu", LoadSceneMode.Single);
			ao.allowSceneActivation = false;
			// Fade out
			playSceneTransitionAudio();
			yield return Camera.main.fadeOut(2);
			// Switch to next scene
			ao.allowSceneActivation = true;
		}

		private void playSceneTransitionAudio()
		{
			// Fade out all audio sources
			GvrAudioSource[] audioSources = FindObjectsOfType<GvrAudioSource>();
			foreach (GvrAudioSource audioSource in audioSources)
				StartCoroutine(audioSource.fadeOut(1));
			// Fade out all ambient sound fields in scene
			GvrAudioSoundfield[] soundfields = FindObjectsOfType<GvrAudioSoundfield>();
			foreach (GvrAudioSoundfield soundfield in soundfields)
				StartCoroutine(soundfield.fadeOut(1));
			// Play transition audio
			GvrAudioSource source = gameObject.AddComponent<GvrAudioSource>();
			source.loop = false;
			source.playOnAwake = false;
			source.clip = sceneTransition;
			source.gainDb = 20f;
			source.Play();
		}
	}
}


text:
layout: page
title: Dixon Card Productions Seminar
date: 2016-05-24
author: Rachel Benton
tags: weekly links, java
status: published
summary: Aliquam malesuada enim sit amet ultrices consectetur. Nullam.
banner: images/banner/office-01.jpg
booking:
  startDate: 03/25/2018
  endDate: 03/26/2018
  ctyhocn: LHQOHHX
  groupCode: DCPS
published: true
---
Nullam interdum justo in dui tristique ultricies. Donec molestie purus est, sed commodo nibh ullamcorper a. Curabitur in est eget elit consectetur semper. Integer euismod arcu eu nisl fermentum, eu bibendum diam sollicitudin. Vestibulum condimentum magna sit amet egestas faucibus. Morbi eget ipsum nec orci tristique ultricies at et magna. Maecenas dictum lorem sed odio elementum imperdiet. Maecenas commodo at nisl at ultricies. Proin porttitor feugiat magna id tempor. Aliquam et lobortis nisl. Phasellus eget nulla et magna venenatis eleifend non et dui.

1 Aenean eget erat eget magna pulvinar posuere
1 Donec tempor nibh non augue pharetra, sit amet efficitur nulla fermentum
1 Morbi vehicula dui eu commodo elementum
1 Vivamus et odio vel leo finibus feugiat
1 Nulla in risus non ligula viverra congue
1 Suspendisse tincidunt ipsum nec massa mattis, eu dapibus leo dignissim.

Suspendisse egestas nisl ac ligula posuere, id fermentum odio lobortis. Donec et metus dictum, convallis sapien vel, consectetur tellus. Praesent nec risus nec felis efficitur tincidunt. Morbi non nulla luctus, condimentum enim vitae, tempus lorem. In ultricies venenatis magna. Ut eget est pulvinar, accumsan dolor at, tincidunt dui. Sed velit libero, lacinia sollicitudin iaculis non, porta vitae turpis. Nullam sit amet quam at orci mollis finibus. Aenean lacinia malesuada metus et sagittis. Phasellus maximus finibus ultrices. Vestibulum ornare bibendum mi, sit amet iaculis dui dapibus sed. Nullam gravida nisi et congue rhoncus. Phasellus a elit ornare, venenatis enim vitae, ullamcorper leo.


text:
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Splitstep
 */
public class JVtestlesson2 {

}


text:
package org.elasticsearch.index.store.cache;

import org.elasticsearch.common.blobstore.BlobContainer;
import org.elasticsearch.common.blobstore.BlobMetadata;
import org.elasticsearch.common.blobstore.BlobPath;
import org.elasticsearch.common.blobstore.DeleteResult;
import org.elasticsearch.common.io.Streams;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.unit.ByteSizeUnit;
import org.elasticsearch.common.unit.ByteSizeValue;
import org.elasticsearch.index.store.IndexInputStats;
import org.elasticsearch.xpack.searchablesnapshots.cache.CacheService;

import java.io.ByteArrayInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
import java.util.Random;

import static com.carrotsearch.randomizedtesting.generators.RandomNumbers.randomIntBetween;
import static com.carrotsearch.randomizedtesting.generators.RandomPicks.randomFrom;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;

public final class TestUtils {
    private TestUtils() {}

    public static void noOpCacheCleaner() {}

    public static CacheService createDefaultCacheService() {
        return new CacheService(TestUtils::noOpCacheCleaner, Settings.EMPTY);
    }

    public static CacheService createCacheService(final Random random) {
        final ByteSizeValue cacheSize = new ByteSizeValue(
            randomIntBetween(random, 1, 100),
            randomFrom(random, List.of(ByteSizeUnit.BYTES, ByteSizeUnit.KB, ByteSizeUnit.MB, ByteSizeUnit.GB))
        );
        return new CacheService(TestUtils::noOpCacheCleaner, cacheSize, randomCacheRangeSize(random));
    }

    public static ByteSizeValue randomCacheRangeSize(final Random random) {
        return new ByteSizeValue(
            randomIntBetween(random, 1, 100),
            randomFrom(random, List.of(ByteSizeUnit.BYTES, ByteSizeUnit.KB, ByteSizeUnit.MB))
        );
    }

    public static long numberOfRanges(long fileSize, long rangeSize) {
        return numberOfRanges(Math.toIntExact(fileSize), Math.toIntExact(rangeSize));
    }

    static long numberOfRanges(int fileSize, int rangeSize) {
        long numberOfRanges = fileSize / rangeSize;
        if (fileSize % rangeSize > 0) {
            numberOfRanges++;
        }
        if (numberOfRanges == 0) {
            numberOfRanges++;
        }
        return numberOfRanges;
    }

    public static void assertCounter(IndexInputStats.Counter counter, long total, long count, long min, long max) {
        assertThat(counter.total(), equalTo(total));
        assertThat(counter.count(), equalTo(count));
        assertThat(counter.min(), equalTo(min));
        assertThat(counter.max(), equalTo(max));
    }

    public static void assertCounter(
        IndexInputStats.TimedCounter timedCounter,
        long total,
        long count,
        long min,
        long max,
        long totalNanoseconds
    ) {
        assertCounter(timedCounter, total, count, min, max);
        assertThat(timedCounter.totalNanoseconds(), equalTo(totalNanoseconds));
    }

    /**
     * A {@link BlobContainer} that can read a single in-memory blob.
     * Any attempt to read a different blob will throw a {@link FileNotFoundException}
     */
    public static BlobContainer singleBlobContainer(final String blobName, final byte[] blobContent) {
        return new MostlyUnimplementedFakeBlobContainer() {
            @Override
            public InputStream readBlob(String name, long position, long length) throws IOException {
                if (blobName.equals(name) == false) {
                    throw new FileNotFoundException("Blob not found: " + name);
                }
                return Streams.limitStream(
                    new ByteArrayInputStream(blobContent, Math.toIntExact(position), blobContent.length - Math.toIntExact(position)),
                    length
                );
            }
        };
    }

    static BlobContainer singleSplitBlobContainer(final String blobName, final byte[] blobContent, final int partSize) {
        if (partSize >= blobContent.length) {
            return singleBlobContainer(blobName, blobContent);
        } else {
            final String prefix = blobName + ".part";
            return new MostlyUnimplementedFakeBlobContainer() {
                @Override
                public InputStream readBlob(String name, long position, long length) throws IOException {
                    if (name.startsWith(prefix) == false) {
                        throw new FileNotFoundException("Blob not found: " + name);
                    }
                    assert position + length <= partSize : "cannot read ["
                        + position
                        + "-"
                        + (position + length)
                        + "] from array part of length ["
                        + partSize
                        + "]";
                    final int partNumber = Integer.parseInt(name.substring(prefix.length()));
                    final int positionInBlob = Math.toIntExact(position) + partSize * partNumber;
                    assert positionInBlob + length <= blobContent.length : "cannot read ["
                        + positionInBlob
                        + "-"
                        + (positionInBlob + length)
                        + "] from array of length ["
                        + blobContent.length
                        + "]";
                    return Streams.limitStream(
                        new ByteArrayInputStream(blobContent, positionInBlob, blobContent.length - positionInBlob),
                        length
                    );
                }
            };
        }
    }

    private static class MostlyUnimplementedFakeBlobContainer implements BlobContainer {

        @Override
        public long readBlobPreferredLength() {
            return Long.MAX_VALUE;
        }

        @Override
        public Map<String, BlobMetadata> listBlobs() {
            throw unsupportedException();
        }

        @Override
        public BlobPath path() {
            throw unsupportedException();
        }

        @Override
        public boolean blobExists(String blobName) {
            throw unsupportedException();
        }

        @Override
        public InputStream readBlob(String blobName) {
            throw unsupportedException();
        }

        @Override
        public InputStream readBlob(String blobName, long position, long length) throws IOException {
            throw unsupportedException();
        }

        @Override
        public void writeBlob(String blobName, InputStream inputStream, long blobSize, boolean failIfAlreadyExists) {
            throw unsupportedException();
        }

        @Override
        public void writeBlobAtomic(String blobName, InputStream inputStream, long blobSize, boolean failIfAlreadyExists) {
            throw unsupportedException();
        }

        @Override
        public DeleteResult delete() {
            throw unsupportedException();
        }

        @Override
        public void deleteBlobsIgnoringIfNotExists(List<String> blobNames) {
            throw unsupportedException();
        }

        @Override
        public Map<String, BlobContainer> children() {
            throw unsupportedException();
        }

        @Override
        public Map<String, BlobMetadata> listBlobsByPrefix(String blobNamePrefix) {
            throw unsupportedException();
        }

        private UnsupportedOperationException unsupportedException() {
            assert false : "this operation is not supported and should have not be called";
            return new UnsupportedOperationException("This operation is not supported");
        }
    }
}


text:
__all__ = ['API_VIEW', 'API_URL']

API_URL = """from django.conf.urls import include, url
try:
  from django.conf.urls import patterns
except ImportError:
  pass
import django
from django.contrib import admin
from {{ app }} import views

if django.VERSION[1] < 10:
  urlpatterns = patterns('',
  {% for model in models %}
    url(r'^{{ model|lower }}/(?P<id>[0-9]+)$', views.{{ model }}APIView.as_view()),
    url(r'^{{ model|lower }}/$', views.{{ model }}APIListView.as_view()),
  {% endfor %}
  )
else:
  urlpatterns = [
  {% for model in models %}
    url(r'^{{ model|lower }}/(?P<id>[0-9]+)$', views.{{ model }}APIView.as_view()),
    url(r'^{{ model|lower }}/$', views.{{ model }}APIListView.as_view()),
  {% endfor %}
  ]
"""

API_VIEW = """from rest_framework.pagination import PageNumberPagination
from rest_framework.response import Response
from rest_framework.views import APIView
from {{ app }}.serializers import {{ serializers|join:', ' }}
from {{ app }}.models import {{ models|join:', ' }}
{% for model in models %}

class {{ model }}APIView(APIView):

    def get(self, request, id, format=None):
        try:
            item = {{ model }}.objects.get(pk=id)
            serializer = {{ model }}Serializer(item)
            return Response(serializer.data)
        except {{ model }}.DoesNotExist:
            return Response(status=404)

    def put(self, request, id, format=None):
        try:
            item = {{ model }}.objects.get(pk=id)
        except {{ model }}.DoesNotExist:
            return Response(status=404)
        serializer = {{ model }}Serializer(item, data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=400)

    def delete(self, request, id, format=None):
        try:
            item = {{ model }}.objects.get(pk=id)
        except {{ model }}.DoesNotExist:
            return Response(status=404)
        item.delete()
        return Response(status=204)

class {{ model }}APIListView(APIView):

    def get(self, request, format=None):
        items = {{ model }}.objects.all()
        paginator = PageNumberPagination()
        result_page = paginator.paginate_queryset(items, request)
        serializer = {{ model }}Serializer(result_page, many=True)
        return paginator.get_paginated_response(serializer.data)

    def post(self, request, format=None):
        serializer = {{ model }}Serializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)
{% endfor %}"""


text:
<?php

class Bloco_Model extends CI_Model {

    public function __construct() {
        parent::__construct();
    }

    public function getBlocoById($id_bloco){
        $this->db->where("idbloco", $id_bloco);
        return $this->db->get('bloco')->result();
    }

    public function getAll() {
        $this->db->order_by('prioridade', "ASC", "nome");
        return $this->db->get('bloco')->result();
    }

    public function insertBloco($nome, $prioridade) {
        $data = [
            "nome" => $nome,
            "prioridade" => $prioridade
        ];
        $this->db->insert('bloco', $data);
    }

    public function updateBloco($id_bloco, $nome, $prioridade) {
        $data = [
            "nome" => $nome,
            "prioridade" => $prioridade
        ];
        $this->db->where('idbloco', $id_bloco);
        $this->db->update('bloco', $data);
    }

    public function deleteBloco($id_bloco){
        $this->db->where('idBloco', $id_bloco);
        $this->db->delete('bloco');
    }

}


text:
package com.flightstats.flex.domain.ratings;

import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.flightstats.flex.domain.Appendix;
import com.flightstats.flex.domain.Rating;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.NoArgsConstructor;
import lombok.Value;

import java.util.List;

@Value
@Builder
@AllArgsConstructor
@NoArgsConstructor(force = true)
@JsonIgnoreProperties(ignoreUnknown = true)
public class RatingsResponse {
    public List<Rating> ratings;
    public Appendix appendix;
}


text:
A basic version of Monopoly for one or more players, built with Ruby on Rails.

## Features

* Collect $200 when passing Go
* Buy properties, utilities and railroads
* Buy up to 5 houses for a property when you own all the properties for one colour-set
* Collect rent when another player lands on a property you own, with or without houses
* Collect rent for a utility based on the previous dice roll
* Collect rent for a railroad based on the number of railroads you own


text:
namespace Envoy {
namespace Ssl {

class ConnectionImpl : public Network::ConnectionImpl, public Connection {
public:
  enum class InitialState { Client, Server };

  ConnectionImpl(Event::DispatcherImpl& dispatcher, int fd,
                 Network::Address::InstanceConstSharedPtr remote_address,
                 Network::Address::InstanceConstSharedPtr local_address,
                 Network::Address::InstanceConstSharedPtr bind_to_address, bool using_original_dst,
                 bool connected, Context& ctx, InitialState state);
  ~ConnectionImpl();

  // Network::Connection
  std::string nextProtocol() const override;
  Ssl::Connection* ssl() override { return this; }
  const Ssl::Connection* ssl() const override { return this; }

  // Ssl::Connection
  bool peerCertificatePresented() const override;
  std::string uriSanLocalCertificate() override;
  std::string sha256PeerCertificateDigest() override;
  std::string subjectPeerCertificate() const override;
  std::string uriSanPeerCertificate() override;

  SSL* rawSslForTest() { return ssl_.get(); }

private:
  PostIoAction doHandshake();
  void drainErrorQueue();
  std::string getUriSanFromCertificate(X509* cert);

  // Network::ConnectionImpl
  bool canFlushClose() override { return handshake_complete_; }
  void closeSocket(Network::ConnectionEvent close_type) override;
  IoResult doReadFromSocket() override;
  IoResult doWriteToSocket() override;
  void onConnected() override;

  ContextImpl& ctx_;
  bssl::UniquePtr<SSL> ssl_;
  bool handshake_complete_{};
};

class ClientConnectionImpl final : public ConnectionImpl, public Network::ClientConnection {
public:
  ClientConnectionImpl(Event::DispatcherImpl& dispatcher, Context& ctx,
                       Network::Address::InstanceConstSharedPtr address,
                       Network::Address::InstanceConstSharedPtr source_address);

  // Network::ClientConnection
  void connect() override;
};

} // namespace Ssl
} // namespace Envoy