import FrontCalculatorParserToken from "./front.calculator.parser.token"; import FrontCalculatorSymbolNumber from "../symbol/front.calculator.symbol.number"; import FrontCalculatorSymbolOpeningBracket from "../symbol/brackets/front.calculator.symbol.opening.bracket"; import FrontCalculatorSymbolClosingBracket from "../symbol/brackets/front.calculator.symbol.closing.bracket"; import FrontCalculatorSymbolFunctionAbstract from "../symbol/abstract/front.calculator.symbol.function.abstract"; import FrontCalculatorSymbolOperatorAbstract from "../symbol/abstract/front.calculator.symbol.operator.abstract"; import FrontCalculatorSymbolSeparator from "../symbol/front.calculator.symbol.separator"; import FrontCalculatorParserNodeSymbol from "./node/front.calculator.parser.node.symbol"; import FrontCalculatorParserNodeContainer from "./node/front.calculator.parser.node.container"; import FrontCalculatorParserNodeFunction from "./node/front.calculator.parser.node.function"; /** * The parsers has one important method: parse() * It takes an array of tokens as input and * returns an array of nodes as output. * These nodes are the syntax tree of the term. * */ export default class FrontCalculatorParser { /** * * @param {FrontCalculatorSymbolLoader} symbolLoader */ constructor(symbolLoader) { /** * * @type {FrontCalculatorSymbolLoader} */ this.symbolLoader = symbolLoader; } /** * Parses an array with tokens. Returns an array of nodes. * These nodes define a syntax tree. * * @param {FrontCalculatorParserToken[]} tokens * * @returns FrontCalculatorParserNodeContainer */ parse(tokens) { var symbolNodes = this.detectSymbols(tokens); var nodes = this.createTreeByBrackets(symbolNodes); nodes = this.transformTreeByFunctions(nodes); this.checkGrammar(nodes); // Wrap the nodes in an array node. return new FrontCalculatorParserNodeContainer(nodes); } /** * Creates a flat array of symbol nodes from tokens. * * @param {FrontCalculatorParserToken[]} tokens * @returns {FrontCalculatorParserNodeSymbol[]} */ detectSymbols(tokens) { var symbolNodes = []; var symbol = null; var identifier = null; var expectingOpeningBracket = false; // True if we expect an opening bracket (after a function name) var openBracketCounter = 0; for (var i = 0; i < tokens.length; i++) { var token = tokens[i]; var type = token.type; if (FrontCalculatorParserToken.TYPE_WORD === type) { identifier = token.value; symbol = this.symbolLoader.find(identifier); if (null === symbol) { throw ('Error: Detected unknown or invalid string identifier: ' + identifier + '.'); } } else if (type === FrontCalculatorParserToken.TYPE_NUMBER) { // Notice: Numbers do not have an identifier var symbolNumbers = this.symbolLoader.findSubTypes(FrontCalculatorSymbolNumber); if (symbolNumbers.length < 1 || !(symbolNumbers instanceof Array)) { throw ('Error: Unavailable number symbol processor.'); } symbol = symbolNumbers[0]; } else {// Type Token::TYPE_CHARACTER: identifier = token.value; symbol = this.symbolLoader.find(identifier); if (null === symbol) { throw ('Error: Detected unknown or invalid string identifier: ' + identifier + '.'); } if (symbol instanceof FrontCalculatorSymbolOpeningBracket) { openBracketCounter++; } if (symbol instanceof FrontCalculatorSymbolClosingBracket) { openBracketCounter--; // Make sure there are not too many closing brackets if (openBracketCounter < 0) { throw ('Error: Found closing bracket that does not have an opening bracket.'); } } } if (expectingOpeningBracket) { if (!(symbol instanceof FrontCalculatorSymbolOpeningBracket)) { throw ('Error: Expected opening bracket (after a function) but got something else.'); } expectingOpeningBracket = false; } else { if (symbol instanceof FrontCalculatorSymbolFunctionAbstract) { expectingOpeningBracket = true; } } var symbolNode = new FrontCalculatorParserNodeSymbol(token, symbol); symbolNodes.push(symbolNode); } // Make sure the term does not end with the name of a function but without an opening bracket if (expectingOpeningBracket) { throw ('Error: Expected opening bracket (after a function) but reached the end of the term'); } // Make sure there are not too many opening brackets if (openBracketCounter > 0) { throw ('Error: There is at least one opening bracket that does not have a closing bracket'); } return symbolNodes; } /** * Expects a flat array of symbol nodes and (if possible) transforms * it to a tree of nodes. Cares for brackets. * Attention: Expects valid brackets! * Check the brackets before you call this method. * * @param {FrontCalculatorParserNodeSymbol[]} symbolNodes * @returns {FrontCalculatorParserNodeAbstract[]} */ createTreeByBrackets(symbolNodes) { var tree = []; var nodesInBracket = []; // AbstractSymbol nodes inside level-0-brackets var openBracketCounter = 0; for (var i = 0; i < symbolNodes.length; i++) { var symbolNode = symbolNodes[i]; if (!(symbolNode instanceof FrontCalculatorParserNodeSymbol)) { throw ('Error: Expected symbol node, but got "' + symbolNode.constructor.name + '"'); } if (symbolNode.symbol instanceof FrontCalculatorSymbolOpeningBracket) { openBracketCounter++; if (openBracketCounter > 1) { nodesInBracket.push(symbolNode); } } else if (symbolNode.symbol instanceof FrontCalculatorSymbolClosingBracket) { openBracketCounter--; // Found a closing bracket on level 0 if (0 === openBracketCounter) { var subTree = this.createTreeByBrackets(nodesInBracket); // Subtree can be empty for example if the term looks like this: "()" or "functioname()" // But this is okay, we need to allow this so we can call functions without a parameter tree.push(new FrontCalculatorParserNodeContainer(subTree)); nodesInBracket = []; } else { nodesInBracket.push(symbolNode); } } else { if (0 === openBracketCounter) { tree.push(symbolNode); } else { nodesInBracket.push(symbolNode); } } } return tree; } /** * Replaces [a SymbolNode that has a symbol of type AbstractFunction, * followed by a node of type ContainerNode] by a FunctionNode. * Expects the $nodes not including any function nodes (yet). * * @param {FrontCalculatorParserNodeAbstract[]} nodes * * @returns {FrontCalculatorParserNodeAbstract[]} */ transformTreeByFunctions(nodes) { var transformedNodes = []; var functionSymbolNode = null; for (var i = 0; i < nodes.length; i++) { var node = nodes[i]; if (node instanceof FrontCalculatorParserNodeContainer) { var transformedChildNodes = this.transformTreeByFunctions(node.childNodes); if (null !== functionSymbolNode) { var functionNode = new FrontCalculatorParserNodeFunction(transformedChildNodes, functionSymbolNode); transformedNodes.push(functionNode); functionSymbolNode = null; } else { // not a function node.childNodes = transformedChildNodes; transformedNodes.push(node); } } else if (node instanceof FrontCalculatorParserNodeSymbol) { var symbol = node.symbol; if (symbol instanceof FrontCalculatorSymbolFunctionAbstract) { functionSymbolNode = node; } else { transformedNodes.push(node); } } else { throw ('Error: Expected array node or symbol node, got "' + node.constructor.name + '"'); } } return transformedNodes; } /** * Ensures the tree follows the grammar rules for terms * * @param {FrontCalculatorParserNodeAbstract[]} nodes */ checkGrammar(nodes) { // TODO Make sure that separators are only in the child nodes of the array node of a function node // (If this happens the calculator will throw an exception) for (var i = 0; i < nodes.length; i++) { var node = nodes[i]; if (node instanceof FrontCalculatorParserNodeSymbol) { var symbol = node.symbol; if (symbol instanceof FrontCalculatorSymbolOperatorAbstract) { var posOfRightOperand = i + 1; // Make sure the operator is positioned left of a (potential) operand (=prefix notation). // Example term: "-1" if (posOfRightOperand >= nodes.length) { throw ('Error: Found operator that does not stand before an operand.'); } var posOfLeftOperand = i - 1; var leftOperand = null; // Operator is unary if positioned at the beginning of a term if (posOfLeftOperand >= 0) { leftOperand = nodes[posOfLeftOperand]; if (leftOperand instanceof FrontCalculatorParserNodeSymbol) { if (leftOperand.symbol instanceof FrontCalculatorSymbolOperatorAbstract // example 1`+-`5 : + = operator, - = unary || leftOperand.symbol instanceof FrontCalculatorSymbolSeparator // example func(1`,-`5) ,= separator, - = unary ) { // Operator is unary if positioned right to another operator leftOperand = null; } } } // If null, the operator is unary if (null === leftOperand) { if (!symbol.operatesUnary) { throw ('Error: Found operator in unary notation that is not unary.'); } // Remember that this node represents a unary operator node.setIsUnaryOperator(true); } else { if (!symbol.operatesBinary) { console.log(symbol); throw ('Error: Found operator in binary notation that is not binary.'); } } } } else { this.checkGrammar(node.childNodes); } } } }.tx-content-switcher-toggle-switch-label{position:relative;display:inline-block;width:60px;height:34px}.tx-content-switcher-toggle-switch-label input{opacity:0;width:0;height:0}.tx-content-switcher-toggle-switch-slider{position:absolute;cursor:pointer;top:0;left:0;right:0;bottom:0;background-color:#ccc;-webkit-transition:.4s;transition:.4s;display:block;border-style:solid}.tx-content-switcher-toggle-switch-slider:before{position:absolute;content:"";height:26px;width:26px;left:0;top:50%;transform:translateY(-50%);background-color:#fff;-webkit-transition:.4s;transition:.4s}input:checked+.tx-content-switcher-toggle-switch-slider{background-color:#2196f3}input:focus+.tx-content-switcher-toggle-switch-slider{box-shadow:0 0 1px #2196f3}input:checked+.tx-content-switcher-toggle-switch-slider:before{-webkit-transform:translate(34px,-50%);-ms-transform:translate(34px,-50%);transform:translate(34px,-50%)}.tx-content-switcher-toggle-inner{display:flex;align-items:center;flex-direction:row;padding:30px 0}.tx-content-switcher-toggle.tx_switecher_left{justify-content:flex-start;display:flex}.tx-content-switcher-toggle.tx_switecher_center{justify-content:center;display:flex}.tx-content-switcher-toggle.tx_switecher_right{justify-content:flex-end;display:flex}.tx-content-switcher-toggle.tx_switecher_justify{display:block}.tx-content-switcher-toggle.tx_switecher_justify .tx-content-switcher-toggle-inner{justify-content:center}.tx-content-switcher-toggle-label-1,.tx-content-switcher-toggle-label-2{cursor:pointer} About - Make My Asset: Premier Gurgaon Real Estate Consultants - Luxury Apartments, Commercial Properties, And Exclusive Listings In Prime Locations

About Us

Who We Are

Make My Asset company provides Optimal solutions to all your realty real-estate investments. We are a well-reputed & prominent real-estate investment company in Gurugram, Haryana with an illustrious platform, where we perform an exclusive role to provide satisfactory services regarding property, home, flat and more. With more industry experience in Gurgaon Real Estate, our team of incredibly experienced and dedicated real estate agents work with you one-on-one to evaluate the most lucrative deals which are right for you. We work with M3M, DLF, Smart World, BPTP, Sun-city, Capital Developer, and Central park. Calling all aspiring real-estate agents! Don’t miss out! Make My Asset, your trusted partner in Gurgaon’s dynamic real estate market. With a mission to make real estate investments straightforward and rewarding, we specialize in curating exceptional residential and commercial properties that align with your goals, whether you’re a first-time buyer, a seasoned investor, or a business owner seeking the ideal location.

About

Our Mission

We are a premium real-estate channel in Gurugram and our main goal is we provide client satisfaction. We dedicated luxurious amenities with cost-effective services & without hustle. Our professionals recommended a residential plot for sale, M3M Studios Apartments with modern amenities and strategically located in the heart of Gurugram, Haryana. And fulfill your desired dream in a comfortable way.

Our Vision

We, value advisors operate excelling in the competitive landscape of real estate, establishing a reputation as a well-respected and innovative agent. Our immersive industry experience treats our clients like family behaviour. We offer a pre-approved project underwriting facility in Gurugram, Haryana. We are a well-known online real estate marketplace based in India. From property sourcing to closing, our comprehensive services include residential and commercial sales, leasing, investment advisory, and property management. We work closely with leading developers, giving you access to the best opportunities in Gurgaon and beyond.

About Real Estate

Why Choose Us?

We offer comprehensive, proficient, & 100% genuine modern amenities with cost-effective & market consulting services also regards customer requirement in Gurugram, Haryana.

  • Top Notch Real-Estate Investment Company: We work with simply the best agents with Excelling and being consistent in everything we do.
  • Priority: With you, till the end our relationship with you doesn’t end once we help you make the right real estate decision. We will assist you with our specialized property management services. Being motivated and spreading our enthusiasm.
  • Trustworthy: Making trust, quality, and integrity hallmarks of the way we do business.
  • Customized Services: Seeking always to be innovative and seeking continual improvement.
  • Cost-effective: We recommended all complete project underwriting paperwork with no extra charges, no brokerage, with required consultation also. 
  • 100% Safe & Secured Investment: We offer genuine & safe services at your doorstep and now, you can easily fulfil your desired dreams and get your home. 
  • Expertise & Integrity: At Make My Asset, we bring years of industry expertise and a reputation for honesty, ensuring every client finds transparency and value in their transactions.
  • Tailored Solutions: Understanding that each client’s requirements are unique, we offer customized property solutions that cater to both personal and financial goals.
  • Unmatched Local Knowledge: With a focus on Gurgaon, we are deeply connected to this region. Our team stays informed on the latest market trends, new developments, and property laws to provide our clients with up-to-date insights.

Our Expertise in Gurgaon’s Property Market

With extensive local knowledge, our team understands the nuances of Gurgaon’s evolving real estate landscape. Whether you’re seeking a new family home in Gurgaon’s prime residential areas or looking for the perfect commercial space in a bustling business hub, we provide you with options that suit your unique needs and objectives.

We specialize in:

  • Residential Sales and Leasing: From luxury apartments to serene gated communities, we offer a range of properties to fit your lifestyle and budget.
  • Commercial Properties: Explore premium office spaces, retail locations, and industrial facilities across Gurgaon’s prominent sectors.
  • Investment Advisory: Our experts analyze trends and emerging markets, offering strategies that help maximize your real estate investments.
  • Property Management: Whether for individuals or large portfolios, we provide management services that protect and enhance the value of your assets.

What Sets Us Apart

  1. Personalized Service: Our team listens and tailors every search to meet your specific requirements, whether you’re buying, leasing, or investing.
  2. Integrity and Transparency: At Make My Asset, we prioritize honesty and open communication. We ensure you have all the details and support you need to make confident decisions.
  3. Market Expertise: With years of experience, we understand Gurgaon’s property values, trends, and future growth areas, helping you make sound investments.
  4. Strong Partnerships: We collaborate with Gurgaon’s top developers and financial institutions to bring you exclusive properties and financing options that aren’t widely available.

Our Commitment to Our Clients

Every client relationship is built on trust, dedication, and the drive to exceed expectations. We are committed to delivering results that match your aspirations, guiding you with expert insights at each stage of your real estate journey. Our services extend beyond property transactions; we’re here as advisors, allies, and long-term partners in your success.

Discover the Future with Make My Asset

At Make My Asset, we envision a future where finding your ideal property is an empowering experience. With a dedication to unmatched service and in-depth market understanding, we are here to help you navigate Gurgaon’s real estate market with confidence.

If you’re ready to explore properties in Gurgaon or invest in lucrative real estate opportunities, reach out to us today. Let us help you turn your aspirations into assets with the expertise and care you deserve.

News

About
Real Estate

Follow us on

Reset password

Enter your email address and we will send you a link to change your password.

Get started with your account

to save your favourite homes and more

Sign up with email

Get started with your account

to save your favourite homes and more

By clicking the «SIGN UP» button you agree to the Terms of Use and Privacy Policy
Powered by Estatik
Scroll to Top