public DualMapGoalTest(System.String goalState1, System.String goalState2)
 {
     this.goalState1 = goalState1;
     this.goalState2 = goalState2;
     goals.Add(goalState1);
     goals.Add(goalState2);
 }

        // ===========================================================
        // Constructors
        // ===========================================================

        public AssetTextureSource(Context pContext, String pAssetPath)
        {
            this.mContext = pContext;
            this.mAssetPath = pAssetPath;

            BitmapFactory.Options decodeOptions = new BitmapFactory.Options();
            decodeOptions.InJustDecodeBounds = true;

            //InputStream input = null;
            System.IO.Stream input = null;
            try
            {
                //input = pContext.getAssets().open(pAssetPath);
                input = pContext.Assets.Open(pAssetPath);
                BitmapFactory.DecodeStream(input, null, decodeOptions);
            }
            catch (IOException e)
            {
                Debug.E("Failed loading Bitmap in AssetTextureSource. AssetPath: " + pAssetPath, e);
            }
            finally
            {
                StreamUtils.CloseStream(input);
            }

            this.mWidth = decodeOptions.OutWidth;
            this.mHeight = decodeOptions.OutHeight;
        }

		internal bool storePayloads; // whether this field stores payloads together with term positions
		
		internal FieldInfo(System.String na, bool tk, int nu, bool storeTermVector, bool storePositionWithTermVector, bool storeOffsetWithTermVector, bool omitNorms, bool storePayloads, bool omitTermFreqAndPositions)
		{
			name = na;
			isIndexed = tk;
			number = nu;
			if (isIndexed)
			{
				this.storeTermVector = storeTermVector;
				this.storeOffsetWithTermVector = storeOffsetWithTermVector;
				this.storePositionWithTermVector = storePositionWithTermVector;
				this.storePayloads = storePayloads;
				this.omitNorms = omitNorms;
				this.omitTermFreqAndPositions = omitTermFreqAndPositions;
			}
			else
			{
				// for non-indexed fields, leave defaults
				this.storeTermVector = false;
				this.storeOffsetWithTermVector = false;
				this.storePositionWithTermVector = false;
				this.storePayloads = false;
				this.omitNorms = true;
				this.omitTermFreqAndPositions = false;
			}
		}

 public static void LogVerbose(String tag, String message, Throwable cause)
 {
     //noinspection PointlessBooleanExpression,ConstantConditions
     if ( Config.Debug && Log.IsLoggable(tag, LogPriority.Verbose)) {
     if (cause != null) Log.Verbose(tag, message, cause);
     }
 }

 public TelParsedResult(System.String number, System.String telURI, System.String title)
     : base(ParsedResultType.TEL)
 {
     this.number = number;
     this.telURI = telURI;
     this.title = title;
 }

        /**
         * Constructs an {@code AttributedString} from an {@code
         * AttributedCharacterIterator}, which represents attributed text.
         *
         * @param iterator
         *            the {@code AttributedCharacterIterator} that contains the text
         *            for this attributed string.
         */
        public AttributedString(AttributedCharacterIterator iterator)
        {
            if (iterator.getBeginIndex() > iterator.getEndIndex()) {
                // text.0A=Invalid substring range
                throw new java.lang.IllegalArgumentException("Invalid substring range"); //$NON-NLS-1$
            }
            StringBuilder buffer = new StringBuilder();
            for (int i = iterator.getBeginIndex(); i < iterator.getEndIndex(); i++) {
                buffer.Append(iterator.current());
                iterator.next();
            }
            text = buffer.ToString();
            java.util.Set<AttributedCharacterIteratorNS.Attribute> attributes = iterator
                    .getAllAttributeKeys();
            if (attributes == null) {
                return;
            }
            attributeMap = new java.util.HashMap<AttributedCharacterIteratorNS.Attribute, java.util.List<IAC_Range>>();//(attributes.size() * 4 / 3) + 1);

            java.util.Iterator<AttributedCharacterIteratorNS.Attribute> it = attributes.iterator();
            while (it.hasNext()) {
                AttributedCharacterIteratorNS.Attribute attribute = it.next();
                iterator.setIndex(0);
                while (iterator.current() != CharacterIteratorConstants.DONE) {
                    int start = iterator.getRunStart(attribute);
                    int limit = iterator.getRunLimit(attribute);
                    System.Object value = iterator.getAttribute(attribute);
                    if (value != null) {
                        addAttribute(attribute, value, start, limit);
                    }
                    iterator.setIndex(limit);
                }
            }
        }

 internal NDEFSmartPosterParsedResult(int action, System.String uri, System.String title)
     : base(ParsedResultType.NDEF_SMART_POSTER)
 {
     this.action = action;
     this.uri = uri;
     this.title = title;
 }

		public TermVectorEntry(System.String field, System.String term, int frequency, TermVectorOffsetInfo[] offsets, int[] positions)
		{
			this.field = field;
			this.term = term;
			this.frequency = frequency;
			this.offsets = offsets;
			this.positions = positions;
		}

 internal EmailAddressParsedResult(System.String emailAddress, System.String subject, System.String body, System.String mailtoURI)
     : base(ParsedResultType.EMAIL_ADDRESS)
 {
     this.emailAddress = emailAddress;
     this.subject = subject;
     this.body = body;
     this.mailtoURI = mailtoURI;
 }

 internal GeoParsedResult(System.String geoURI, double latitude, double longitude, double altitude)
     : base(ParsedResultType.GEO)
 {
     this.geoURI = geoURI;
     this.latitude = latitude;
     this.longitude = longitude;
     this.altitude = altitude;
 }

        public static void TrackAppEvent(String eventCategory, String eventToTrack)
        {
            var builder = new HitBuilders.EventBuilder();
            builder.SetCategory(eventCategory);
            builder.SetAction(eventToTrack);
            builder.SetLabel("AppEvent");

            Rep.Instance.GaTracker.Send(builder.Build());
        }

 static StopAnalyzer()
 {
     {
         var stopWords = new System.String[]{"a", "an", "and", "are", "as", "at", "be", "but", "by", "for", "if", "in", "into", "is", "it", "no", "not", "of", "on", "or", "such", "that", "the", "their", "then", "there", "these", "they", "this", "to", "was", "will", "with"};
         var stopSet = new CharArraySet(stopWords.Length, false);
         stopSet.AddAll(stopWords);
         ENGLISH_STOP_WORDS_SET = CharArraySet.UnmodifiableSet(stopSet);
     }
 }

 public uc_formpartsinfo(
     System.String p1,
     System.Drawing.Point p2,
     System.Drawing.Point p3
     )
 {
     param = p1;
     prmStartPos = p2;
     prmEndPos = p3;
 }

 public SMSParsedResult(System.String smsURI, System.String number, System.String via, System.String subject, System.String body, System.String title)
     : base(ParsedResultType.SMS)
 {
     this.smsURI = smsURI;
     this.number = number;
     this.via = via;
     this.subject = subject;
     this.body = body;
     this.title = title;
 }

        public static void TrackAppException(String activity, String method, string exceptionName, string message, Boolean isFatalException)
        {
            var builder = new HitBuilders.ExceptionBuilder();
            var exceptionMessageToTrack = string.Format("{0}, Method : {1}\nException Name : {2}\nMessage : \n{3}", activity, method,
                exceptionName, message);
            builder.SetDescription(exceptionMessageToTrack);
            builder.SetFatal(isFatalException);

            Rep.Instance.GaTracker.Send(builder.Build());
        }

		public DecoderResult(sbyte[] rawBytes, System.String text, System.Collections.ArrayList byteSegments, ErrorCorrectionLevel ecLevel)
		{
			if (rawBytes == null && text == null)
			{
				throw new System.ArgumentException();
			}
			this.rawBytes = rawBytes;
			this.text = text;
			this.byteSegments = byteSegments;
			this.ecLevel = ecLevel;
		}

		public SegmentWriteState(DocumentsWriter docWriter, Directory directory, System.String segmentName, System.String docStoreSegmentName, int numDocs, int numDocsInStore, int termIndexInterval)
		{
			this.docWriter = docWriter;
			this.directory = directory;
			this.segmentName = segmentName;
			this.docStoreSegmentName = docStoreSegmentName;
			this.numDocs = numDocs;
			this.numDocsInStore = numDocsInStore;
			this.termIndexInterval = termIndexInterval;
            flushedFiles = new System.Collections.Generic.HashSet<string>();
		}

        // ===========================================================
        // Constructors
        // ===========================================================

        // ===========================================================
        // Getter & Setter
        // ===========================================================

        /**
         * @param pAssetBasePath must end with '<code>/</code>' or have <code>.length() == 0</code>.
         */
        public static void SetAssetBasePath(String pAssetBasePath)
        {
            if (pAssetBasePath.EndsWith("/") || pAssetBasePath.Length == 0)
            {
                MusicFactory.sAssetBasePath = pAssetBasePath;
            }
            else
            {
                throw new IllegalStateException("pAssetBasePath must end with '/' or be lenght zero.");
            }
        }

 public NvtParserEventArgs(
     NvtActions        p1,
     System.Char       p2,
     System.String     p3,
     uc_Params         p4)
 {
     //prntSome.printSome("NvtParserEventArgs");
     Action       = p1;
     CurChar      = p2;
     CurSequence  = p3;
     CurParams    = p4;
 }

		public CompoundFileReader(Directory dir, System.String name, int readBufferSize)
		{
			directory = dir;
			fileName = name;
			this.readBufferSize = readBufferSize;
			
			bool success = false;
			
			try
			{
				stream = dir.OpenInput(name, readBufferSize);
				
				// read the directory and init files
				int count = stream.ReadVInt();
				FileEntry entry = null;
				for (int i = 0; i < count; i++)
				{
					long offset = stream.ReadLong();
					System.String id = stream.ReadString();
					
					if (entry != null)
					{
						// set length of the previous entry
						entry.length = offset - entry.offset;
					}

					entry = new FileEntry {offset = offset};
					entries[id] = entry;
				}
				
				// set the length of the final entry
				if (entry != null)
				{
					entry.length = stream.Length() - entry.offset;
				}
				
				success = true;
			}
			finally
			{
				if (!success && (stream != null))
				{
					try
					{
						stream.Close();
					}
					catch (System.IO.IOException)
					{
					}
				}
			}
		}